Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #28134 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-02-26 13:53 -0600 |
| Last post | 2021-03-09 18:31 -0800 |
| Articles | 20 on this page of 736 — 18 participants |
Back to article view | Back to comp.theory
Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-26 13:53 -0600
Re: Detecting infinite recursion Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-02-26 12:41 -0800
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-26 15:00 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-02-27 10:18 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-27 09:26 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-02-27 13:57 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-27 14:40 -0600
Re: Detecting infinite recursion Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-02-27 21:52 +0000
Re: Detecting infinite recursion Jeff Barnett <jbb@notatt.com> - 2021-02-27 15:10 -0700
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-27 16:12 -0600
Re: Detecting infinite recursion Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-02-27 22:42 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-27 18:37 -0600
Re: Detecting infinite recursion Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-02-28 11:46 +0000
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-02-27 21:43 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-27 20:59 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-02-27 22:30 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-27 22:10 -0600
Re: Detecting infinite recursion Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-02-28 14:24 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-28 08:34 -0600
Re: Detecting infinite recursion Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-02-28 16:26 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-28 10:34 -0600
Re: Detecting infinite recursion Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-02-28 17:20 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-02-28 13:08 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-02-28 20:15 +0000
Re: Detecting infinite recursion (H_Hat is proved to be halting decidable) olcott <NoOne@NoWhere.com> - 2021-02-28 14:55 -0600
Re: Detecting infinite recursion (H_Hat is proved to be halting decidable) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-01 02:30 +0000
Re: Detecting infinite recursion (H_Hat is proved to be halting decidable) olcott <NoOne@NoWhere.com> - 2021-02-28 20:51 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-01 03:52 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-02-28 22:19 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-01 13:10 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 08:30 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-01 15:20 +0000
Re: Detecting infinite recursion (H_Hat is proved to be halting decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 09:41 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 08:24 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-01 17:06 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-01 16:52 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 11:30 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-01 18:25 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 12:47 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-01 14:29 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 15:17 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-01 16:31 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 15:50 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-01 17:54 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 17:46 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-01 19:54 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-01 19:39 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 14:22 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-01 22:42 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 17:00 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-02 01:00 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 19:31 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-02 02:22 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 21:05 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-01 21:32 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-02 02:34 -0800
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 08:45 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 10:55 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 09:58 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 12:01 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 11:42 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 13:05 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-03 14:54 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-03 12:41 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-03 21:13 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-03 15:37 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-02 12:02 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 09:29 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-03 00:53 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 19:02 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-03 01:26 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 19:35 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-03 01:52 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 20:14 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 21:49 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 21:31 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 23:12 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 22:30 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 07:49 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-03 11:44 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-03 12:08 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-03 22:35 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 17:42 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-03 16:59 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 18:23 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-03 17:34 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 19:36 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-03 18:45 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 20:40 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) olcott <NoOne@NoWhere.com> - 2021-03-02 19:43 -0600
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 21:19 -0500
Re: Detecting infinite recursion (H_Hat is proved to be decidable) om@iki.fi (Otto J. Makela) - 2021-03-03 14:52 +0200
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-03 13:52 +0000
Re: Detecting infinite recursion (H_Hat is proved to be decidable) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-02-28 21:51 -0800
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-01 11:30 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-01 10:43 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-01 14:38 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-01 15:30 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-01 17:33 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-01 16:40 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-01 18:08 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-01 17:37 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-01 19:22 -0500
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-02-27 21:19 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-27 20:36 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-02-27 22:01 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-27 21:30 -0600
Re: Detecting infinite recursion Siri Cruise <chine.bleu@yahoo.com> - 2021-02-26 12:48 -0800
Re: Detecting infinite recursion Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-02-26 21:37 +0000
Re: Detecting infinite recursion Siri Cruise <chine.bleu@yahoo.com> - 2021-02-26 15:26 -0800
Re: Detecting infinite recursion "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-02-26 21:49 -0800
Re: Detecting infinite recursion "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-02-26 21:56 -0800
Re: Detecting infinite recursion Kaz Kylheku <563-365-8930@kylheku.com> - 2021-02-27 01:58 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-02-26 21:24 -0600
Re: Detecting infinite recursion Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-02-27 03:32 +0000
Re: Detecting infinite recursion Jeff Barnett <jbb@notatt.com> - 2021-02-26 21:32 -0700
Re: Detecting infinite recursion "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-01 20:04 -0800
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-01 22:18 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 07:03 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 09:33 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 11:00 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 10:23 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 11:53 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 11:37 -0600
Re: Detecting infinite recursion Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-02 09:43 -0800
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 11:57 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 13:16 -0500
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 12:57 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 13:12 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 15:40 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 14:51 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 16:00 -0500
Re: Detecting infinite recursion om@iki.fi (Otto J. Makela) - 2021-03-02 18:36 +0200
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 11:55 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 11:22 -0600
Re: Detecting infinite recursion Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-02 17:46 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 13:00 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 14:15 -0500
Re: Detecting infinite recursion Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-02 19:35 +0000
Re: Detecting infinite recursion R Kym Horsell <kym@kymhorsell.com> - 2021-03-02 19:37 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 13:58 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 15:50 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 13:50 -0600
Re: Detecting infinite recursion Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-02 19:57 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 14:20 -0600
Re: Detecting infinite recursion Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-03-02 12:57 -0800
Re: Detecting infinite recursion gazelle@shell.xmission.com (Kenny McCormack) - 2021-03-03 02:17 +0000
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 13:20 -0500
Re: Detecting infinite recursion Siri Cruise <chine.bleu@yahoo.com> - 2021-03-02 11:45 -0800
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 13:52 -0600
Re: Detecting infinite recursion Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-02 12:01 -0800
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 14:41 -0600
Re: Detecting infinite recursion Alan Mackenzie <acm@muc.de> - 2021-03-02 21:01 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 15:11 -0600
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 15:19 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 17:15 -0500
Re: Detecting infinite recursion (halt decider spec) olcott <NoOne@NoWhere.com> - 2021-03-02 16:38 -0600
Re: Detecting infinite recursion (halt decider spec) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 20:44 -0500
Re: Detecting infinite recursion (halt decider spec) olcott <NoOne@NoWhere.com> - 2021-03-02 19:48 -0600
Re: Detecting infinite recursion (halt decider spec) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 21:25 -0500
Re: Detecting infinite recursion (halt decider spec) olcott <NoOne@NoWhere.com> - 2021-03-02 20:40 -0600
Re: Detecting infinite recursion (halt decider spec) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 21:57 -0500
Re: Detecting infinite recursion (halt decider spec) olcott <NoOne@NoWhere.com> - 2021-03-02 21:03 -0600
Re: Detecting infinite recursion (halt decider spec) olcott <NoOne@NoWhere.com> - 2021-03-02 21:05 -0600
Re: Detecting infinite recursion (halt decider spec) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 22:29 -0500
Re: Detecting infinite recursion (halt decider spec) olcott <NoOne@NoWhere.com> - 2021-03-02 21:33 -0600
Re: Detecting infinite recursion (halt decider spec) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 22:54 -0500
Re: Detecting infinite recursion (halt decider spec) olcott <NoOne@NoWhere.com> - 2021-03-02 21:58 -0600
Re: Detecting infinite recursion (halt decider spec) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 23:24 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-02 22:49 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 08:07 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 09:26 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 12:35 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 12:13 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 17:27 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 16:34 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 17:59 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-03 23:30 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 18:05 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 19:39 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 18:46 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 22:19 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 01:23 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 19:45 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 01:56 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 20:15 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 02:32 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 20:48 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 22:27 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 21:38 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 22:58 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 22:10 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 23:25 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 16:34 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 11:45 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 01:31 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 19:50 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 02:43 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 21:01 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 23:04 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 23:50 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-05 09:44 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 12:03 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 09:09 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-05 10:36 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 16:19 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 10:25 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-05 11:45 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 21:16 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 15:31 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-06 13:58 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 09:01 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 10:12 -0500
Re: Detecting infinite recursion (pathological self-reference error) olcott <NoOne@NoWhere.com> - 2021-03-06 09:58 -0600
Re: Detecting infinite recursion (pathological self-reference error) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 11:33 -0500
Re: Detecting infinite recursion (pathological self-reference error) olcott <NoOne@NoWhere.com> - 2021-03-06 10:59 -0600
Re: Detecting infinite recursion (pathological self-reference error) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 15:10 -0500
Re: Detecting infinite recursion (pathological self-reference error) olcott <NoOne@NoWhere.com> - 2021-03-06 14:40 -0600
Re: Detecting infinite recursion (pathological self-reference error) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 17:28 -0500
Re: Detecting infinite recursion (PDF) olcott <NoOne@NoWhere.com> - 2021-03-06 16:52 -0600
Re: Detecting infinite recursion (PDF) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 18:34 -0500
Re: Detecting infinite recursion (PDF) olcott <NoOne@NoWhere.com> - 2021-03-06 17:38 -0600
Re: Detecting infinite recursion (PDF) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 19:10 -0500
Re: Detecting infinite recursion (PDF) olcott <NoOne@NoWhere.com> - 2021-03-06 18:27 -0600
Re: Detecting infinite recursion (PDF) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 19:36 -0500
Re: Detecting infinite recursion (PDF) olcott <NoOne@NoWhere.com> - 2021-03-06 18:50 -0600
Re: Detecting infinite recursion (PDF) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 20:34 -0500
Re: Detecting infinite recursion (deciding Simulate) olcott <NoOne@NoWhere.com> - 2021-03-06 20:36 -0600
Re: Detecting infinite recursion (deciding Simulate) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 22:05 -0500
Re: Detecting infinite recursion (deciding Simulate) olcott <NoOne@NoWhere.com> - 2021-03-06 21:18 -0600
Re: Detecting infinite recursion (deciding Simulate) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 22:53 -0500
Re: Detecting infinite recursion (deciding Simulate) olcott <NoOne@NoWhere.com> - 2021-03-06 22:01 -0600
Re: Detecting infinite recursion (deciding Simulate) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 08:35 -0500
Re: Detecting infinite recursion (deciding Simulate) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-07 15:30 -0800
Re: Detecting infinite recursion (deciding Simulate) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 20:49 -0500
Re: Detecting infinite recursion (deciding Simulate) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-07 22:37 -0800
Re: Detecting infinite recursion (deciding Simulate) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-08 12:01 +0000
Re: Detecting infinite recursion (deciding Simulate) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-08 18:01 -0800
Re: Detecting infinite recursion (deciding Simulate) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 09:12 -0500
Re: Detecting infinite recursion (deciding Simulate) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-08 18:03 -0800
Re: Detecting infinite recursion (deciding Simulate) André G. Isaak <agisaak@gm.invalid> - 2021-03-06 21:01 -0700
Re: Detecting infinite recursion (deciding Simulate) olcott <NoOne@NoWhere.com> - 2021-03-06 22:09 -0600
Re: Detecting infinite recursion (deciding Simulate) André G. Isaak <agisaak@gm.invalid> - 2021-03-06 21:23 -0700
Re: Detecting infinite recursion (deciding Simulate) olcott <NoOne@NoWhere.com> - 2021-03-06 22:27 -0600
Re: Detecting infinite recursion (deciding Simulate) André G. Isaak <agisaak@gm.invalid> - 2021-03-06 23:56 -0700
Re: Detecting infinite recursion (deciding Simulate) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-07 15:35 -0800
Re: Detecting infinite recursion (deciding Simulate) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-07 05:46 +0000
Re: Detecting infinite recursion (deciding Simulate) olcott <NoOne@NoWhere.com> - 2021-03-07 00:17 -0600
Re: Detecting infinite recursion (deciding Simulate) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 08:59 -0500
Re: Detecting infinite recursion (deciding Simulate) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-07 15:35 -0800
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 00:57 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 19:11 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 01:41 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 19:50 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 11:53 +0000
Re: Detecting infinite recursion (halt deciding criteria) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-05 13:39 -0800
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 15:55 -0600
Re: Detecting infinite recursion (halt deciding criteria) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-06 01:41 +0000
Re: Detecting infinite recursion (halt deciding criteria) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-06 16:50 -0800
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-03 21:41 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 15:50 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 00:44 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 19:01 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 01:46 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 20:13 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 02:34 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 20:57 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 16:44 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 11:42 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-04 19:36 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 13:42 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-04 20:55 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 15:12 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 17:08 -0500
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 14:56 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 14:19 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 15:48 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 15:07 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 17:25 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 16:44 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 18:26 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 17:37 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-04 15:54 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 17:17 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-04 16:36 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 17:46 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-04 17:46 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 19:13 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-04 18:31 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 19:37 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-04 21:13 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 22:29 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-04 22:08 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 23:20 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-04 22:57 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 00:07 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-04 23:51 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 08:25 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-05 09:23 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 10:27 -0600
Re: Detecting infinite recursion (halt deciding criteria) André G. Isaak <agisaak@gm.invalid> - 2021-03-05 12:26 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 13:47 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-05 15:20 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 19:07 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-05 20:48 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 20:01 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-05 21:21 -0500
Re: Detecting infinite recursion (halt deciding criteria) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-04 15:23 -0800
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 17:35 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-04 21:05 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 15:15 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-05 04:17 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 22:46 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 11:26 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 08:56 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 15:45 +0000
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 10:00 -0600
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-05 11:17 -0500
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 17:39 +0000
Deciding the [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 11:47 -0600
Re: Deciding the [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-05 15:22 -0500
Re: Deciding the [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 14:40 -0600
Re: Deciding the [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-05 20:55 -0500
Re: Deciding the [would-not-halt] property Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 00:53 +0000
Re: Deciding the [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-06 19:01 -0600
Re: Deciding the [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-06 20:36 -0500
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-05 12:43 -0800
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 14:59 -0600
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-05 13:33 -0800
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 16:01 -0600
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property André G. Isaak <agisaak@gm.invalid> - 2021-03-05 18:08 -0700
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 19:20 -0600
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property André G. Isaak <agisaak@gm.invalid> - 2021-03-05 18:32 -0700
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 19:41 -0600
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property André G. Isaak <agisaak@gm.invalid> - 2021-03-05 18:47 -0700
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 19:59 -0600
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property André G. Isaak <agisaak@gm.invalid> - 2021-03-05 20:11 -0700
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 21:28 -0600
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property André G. Isaak <agisaak@gm.invalid> - 2021-03-05 20:47 -0700
Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-05 22:12 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) André G. Isaak <agisaak@gm.invalid> - 2021-03-05 21:39 -0700
Re: Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-05 23:17 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) André G. Isaak <agisaak@gm.invalid> - 2021-03-05 22:31 -0700
Re: Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-05 23:35 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-06 02:36 -0800
Re: Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-06 08:37 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) André G. Isaak <agisaak@gm.invalid> - 2021-03-06 08:16 -0700
Re: Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-06 09:32 -0600
Re: Deciding the [would-not-halt] property (identical functions) olcott <NoOne@NoWhere.com> - 2021-03-06 11:48 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 06:10 -0500
Re: Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-06 08:41 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 10:05 -0500
Re: Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-06 09:51 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) André G. Isaak <agisaak@gm.invalid> - 2021-03-06 08:09 -0700
Re: Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-06 09:28 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 06:05 -0500
Re: Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-06 08:39 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 10:08 -0500
Re: Deciding the [would-not-halt] property (André's ignorance) olcott <NoOne@NoWhere.com> - 2021-03-06 09:53 -0600
Re: Deciding the [would-not-halt] property (André's ignorance) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 11:16 -0500
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-05 23:52 -0500
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-05 21:02 -0500
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-05 21:00 -0500
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-05 23:59 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 18:23 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 16:17 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 10:33 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 11:54 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 11:08 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 15:14 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 14:44 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 17:34 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 16:56 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 19:26 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 18:34 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 20:56 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 20:10 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 22:10 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 21:23 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 23:05 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 22:20 -0600
Re: Detecting infinite recursion (halt deciding criteria) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-06 20:27 -0800
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 09:11 -0500
Re: Detecting infinite recursion (halt deciding criteria) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-07 06:29 -0800
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 11:58 -0500
Re: Detecting infinite recursion (halt deciding criteria) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-07 15:17 -0800
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-07 17:21 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-08 01:19 +0000
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-07 19:34 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 20:51 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-07 20:01 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 22:11 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-07 21:19 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 22:40 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-07 21:50 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 09:28 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-08 09:39 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 11:25 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-08 10:34 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 11:51 -0500
Re: Detecting infinite recursion (1931 Gödel) André G. Isaak <agisaak@gm.invalid> - 2021-03-07 20:32 -0700
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-07 21:48 -0600
Re: Detecting infinite recursion (1931 Gödel) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-08 11:44 +0000
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 09:35 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-08 09:44 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 11:30 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-08 10:52 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 12:07 -0500
Re: Detecting infinite recursion (1931 Gödel) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-08 02:24 +0000
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-07 20:28 -0600
Re: Detecting infinite recursion (1931 Gödel) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-08 02:33 +0000
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-07 20:37 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 22:14 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-07 21:22 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 22:45 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-07 21:52 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 10:01 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-08 09:50 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 11:33 -0500
Re: Detecting infinite recursion (1931 Gödel) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-07 22:17 -0800
Re: Detecting infinite recursion (1931 Gödel) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-08 12:34 +0000
Re: Detecting infinite recursion (1931 Gödel) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-08 04:58 -0800
Re: Detecting infinite recursion (1931 Gödel) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-08 09:11 -0800
Re: Detecting infinite recursion (1931 Gödel) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-08 09:28 -0800
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-08 09:26 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 11:34 -0500
Re: Detecting infinite recursion (1931 Gödel) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 16:54 +0000
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-08 11:12 -0600
Re: Detecting infinite recursion (1931 Gödel) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 17:48 +0000
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-08 12:21 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 13:43 -0500
Re: Detecting infinite recursion (1931 Gödel) olcott <NoOne@NoWhere.com> - 2021-03-08 13:49 -0600
Re: Detecting infinite recursion (1931 Gödel) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 15:19 -0500
Re: Detecting infinite recursion (Haskell Curry) olcott <NoOne@NoWhere.com> - 2021-03-08 20:38 -0600
Re: Detecting infinite recursion (Haskell Curry) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-08 18:55 -0800
Re: Detecting infinite recursion (1931 Gödel) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-09 00:30 +0000
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 20:59 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 11:34 +0000
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 11:30 +0000
Re: Detecting infinite recursion (halt deciding criteria) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-07 02:47 -0800
Re: Detecting infinite recursion (incorrect questions) olcott <NoOne@NoWhere.com> - 2021-03-07 09:27 -0600
Re: Detecting infinite recursion (incorrect questions) olcott <NoOne@NoWhere.com> - 2021-03-07 09:36 -0600
Re: Detecting infinite recursion (incorrect questions) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 21:04 -0500
Re: Detecting infinite recursion (incorrect questions) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 02:24 +0000
Re: Detecting infinite recursion (incorrect questions) olcott <NoOne@NoWhere.com> - 2021-03-07 20:32 -0600
Re: Detecting infinite recursion (incorrect questions) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 02:59 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 23:20 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 16:18 +0000
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-05 23:42 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 18:19 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 04:56 +0000
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 06:17 -0500
Re: Detecting infinite recursion (halt deciding criteria) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-06 05:05 -0800
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 08:48 -0600
Re: Detecting infinite recursion (halt deciding criteria) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-06 09:47 -0800
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 11:52 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 15:19 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 15:00 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 17:59 -0500
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 23:16 +0000
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 16:33 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 10:45 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 17:02 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 11:15 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 18:07 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 12:14 -0600
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 12:25 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 19:06 +0000
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 18:25 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 12:53 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 19:13 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 14:25 -0600
Re: Detecting infinite recursion (halt deciding criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 21:00 +0000
Re: Detecting infinite recursion (PDF) olcott <NoOne@NoWhere.com> - 2021-03-06 15:35 -0600
Re: Detecting infinite recursion (PDF) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-06 23:07 +0000
Re: Detecting infinite recursion (PDF) olcott <NoOne@NoWhere.com> - 2021-03-06 17:33 -0600
Re: Detecting infinite recursion (PDF) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-07 03:34 +0000
Re: Detecting infinite recursion (PDF) olcott <NoOne@NoWhere.com> - 2021-03-06 21:40 -0600
Re: Detecting infinite recursion (PDF) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-07 17:16 +0000
Re: Detecting infinite recursion (PDF) olcott <NoOne@NoWhere.com> - 2021-03-07 17:12 -0600
Re: Detecting infinite recursion (PDF) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 02:11 +0000
Re: Detecting infinite recursion (PDF) (Ignoramus?) olcott <NoOne@NoWhere.com> - 2021-03-07 20:17 -0600
Re: Detecting infinite recursion (PDF) (Ignoramus?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 02:55 +0000
Re: Detecting infinite recursion (PDF) (Ignoramus?) olcott <NoOne@NoWhere.com> - 2021-03-07 21:06 -0600
Re: Detecting infinite recursion (PDF) (Ignoramus?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 04:43 +0000
Re: Detecting infinite recursion (PDF) (last step?) olcott <NoOne@NoWhere.com> - 2021-03-07 22:51 -0600
Re: Detecting infinite recursion (PDF) (Ignoramus?) olcott <NoOne@NoWhere.com> - 2021-03-07 22:39 -0600
Re: Detecting infinite recursion (PDF) (Ignoramus?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 04:55 +0000
Re: Detecting infinite recursion (PDF) (last step?) olcott <NoOne@NoWhere.com> - 2021-03-07 23:05 -0600
Re: Detecting infinite recursion (PDF) (last step?) olcott <NoOne@NoWhere.com> - 2021-03-07 23:20 -0600
Re: Detecting infinite recursion (PDF) (last step?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 06:16 +0000
Re: Detecting infinite recursion (PDF) (last step?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 06:13 +0000
Re: Detecting infinite recursion (PDF) (last step?) olcott <NoOne@NoWhere.com> - 2021-03-08 00:21 -0600
Re: Detecting infinite recursion (PDF) (last step?) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-07 22:30 -0800
Re: Detecting infinite recursion (PDF) (last step?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 07:07 +0000
Re: Detecting infinite recursion (PDF) (agreement?) olcott <NoOne@NoWhere.com> - 2021-03-08 09:23 -0600
Re: Detecting infinite recursion (PDF) (agreement?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 17:16 +0000
Re: Detecting infinite recursion (PDF) (agreement?) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-08 09:26 -0800
Re: Detecting infinite recursion (PDF) (agreement?) olcott <NoOne@NoWhere.com> - 2021-03-08 11:36 -0600
Re: Detecting infinite recursion (PDF) (agreement?) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-08 09:52 -0800
Re: Detecting infinite recursion (PDF) (agreement?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 17:59 +0000
Re: Detecting infinite recursion (PDF) (agreement?) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-08 10:07 -0800
Re: Detecting infinite recursion (PDF) (agreement?) olcott <NoOne@NoWhere.com> - 2021-03-08 12:31 -0600
Re: Detecting infinite recursion (PDF) (agreement?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 18:41 +0000
Re: Detecting infinite recursion (PDF) (agreement?) olcott <NoOne@NoWhere.com> - 2021-03-08 12:55 -0600
Re: Detecting infinite recursion (PDF) (agreement?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 19:29 +0000
Re: Detecting infinite recursion (PDF) (agreement?) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 14:50 -0500
Re: Detecting infinite recursion (PDF) (agreement?) olcott <NoOne@NoWhere.com> - 2021-03-08 14:02 -0600
Re: Detecting infinite recursion (PDF) (agreement?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 20:52 +0000
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 15:15 -0600
Re: Detecting infinite recursion (PDF) (nitwit) André G. Isaak <agisaak@gm.invalid> - 2021-03-08 14:43 -0700
Re: Detecting infinite recursion (PDF) (nitwit) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 00:03 +0000
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 18:59 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 20:24 -0500
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 19:54 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 03:14 +0000
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 21:20 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 22:42 -0500
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 21:47 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 22:57 -0500
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 22:11 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 07:46 -0500
Re: Detecting infinite recursion (PDF) (nitwit) André G. Isaak <agisaak@gm.invalid> - 2021-03-08 20:54 -0700
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 22:09 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 07:55 -0500
Re: Detecting infinite recursion (PDF) (nitwit) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 04:17 +0000
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 22:28 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 05:52 +0000
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-09 00:03 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-09 04:12 -0800
Re: Detecting infinite recursion (PDF) (nitwit) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 15:51 +0000
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-09 10:07 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 11:33 -0500
Re: Detecting infinite recursion (PDF) (nitwit) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 17:00 +0000
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-09 11:08 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 12:27 -0500
Re: Detecting infinite recursion (PDF) (nitwit) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 17:28 +0000
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-09 11:37 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 12:44 -0500
Re: Detecting infinite recursion (PDF) (nitwit) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 17:59 +0000
Re: Detecting infinite recursion (PDF) (nitwit) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-09 17:29 +0000
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 07:59 -0500
Re: Detecting infinite recursion (PDF) (nitwit) R Kym Horsell <kym@kymhorsell.com> - 2021-03-09 16:16 +0000
Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 10:26 -0600
Re: Refuting the halting problem proofs with fully operational code Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-09 16:46 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 10:51 -0600
Re: Refuting the halting problem proofs with fully operational code Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-09 16:54 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 11:00 -0600
Re: Refuting the halting problem proofs with fully operational code Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-09 17:04 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 11:10 -0600
Re: Refuting the halting problem proofs with fully operational code R Kym Horsell <kym@kymhorsell.com> - 2021-03-09 16:57 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 11:02 -0600
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 17:17 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 11:24 -0600
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 17:35 +0000
Re: Refuting the halting problem proofs with fully operational code (pathological self-reference error) olcott <NoOne@NoWhere.com> - 2021-03-09 11:54 -0600
Re: Refuting the halting problem proofs with fully operational code (pathological self-reference error) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 18:02 +0000
Re: Refuting the halting problem proofs with fully operational code (pathological self-reference error) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 13:57 -0500
Re: Refuting the halting problem proofs with fully operational code Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-09 10:04 -0800
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 12:12 -0600
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 18:37 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 12:57 -0600
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 14:26 -0500
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 14:46 -0600
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 16:48 -0500
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 15:56 -0600
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 17:49 -0500
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:26 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 20:47 -0600
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 03:14 +0000
Re: Refuting the halting problem proofs with fully operational code Jeff Barnett <jbb@notatt.com> - 2021-03-10 11:36 -0700
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-10 12:58 -0600
Re: Refuting the halting problem proofs with fully operational code Jeff Barnett <jbb@notatt.com> - 2021-03-10 15:35 -0700
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-09 19:28 +0000
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 14:00 -0500
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 13:03 -0600
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 14:25 -0500
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-09 21:39 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 15:59 -0600
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 16:52 -0600
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 12:42 -0500
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 12:36 -0500
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 22:36 -0500
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 21:45 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 23:02 -0500
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 22:13 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 08:00 -0500
Re: Detecting infinite recursion (PDF) (nitwit) André G. Isaak <agisaak@gm.invalid> - 2021-03-08 21:22 -0700
Re: Detecting infinite recursion (PDF) (nitwit) olcott <NoOne@NoWhere.com> - 2021-03-08 22:35 -0600
Re: Detecting infinite recursion (PDF) (nitwit) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-08 20:42 -0800
Re: Detecting infinite recursion (PDF) (nitwit) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 08:07 -0500
Re: Detecting infinite recursion (PDF) (agreement?) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 13:32 -0500
Re: Detecting infinite recursion (PDF) (agreement?) olcott <NoOne@NoWhere.com> - 2021-03-08 11:31 -0600
Re: Detecting infinite recursion (PDF) (agreement?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 18:04 +0000
Re: Detecting infinite recursion (PDF) (agreement?) olcott <NoOne@NoWhere.com> - 2021-03-08 12:34 -0600
Re: Detecting infinite recursion (PDF) (agreement?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 19:07 +0000
Re: Detecting infinite recursion (PDF) (agreement?) olcott <NoOne@NoWhere.com> - 2021-03-08 14:01 -0600
Re: Detecting infinite recursion (PDF) (agreement?) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 15:34 -0500
Re: Detecting infinite recursion (PDF) (Rice's theorem) olcott <NoOne@NoWhere.com> - 2021-03-08 15:57 -0600
Re: Detecting infinite recursion (PDF) (Rice's theorem) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 17:20 -0500
Re: Detecting infinite recursion (PDF) (last step?) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-07 23:57 -0800
Re: Detecting infinite recursion (PDF) (last step?) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 09:37 -0500
Re: Detecting infinite recursion (PDF) (last step?) olcott <NoOne@NoWhere.com> - 2021-03-08 09:28 -0600
Re: Detecting infinite recursion (PDF) (last step?) Richard Damon <Richard@Damon-Family.org> - 2021-03-08 11:37 -0500
Re: Detecting infinite recursion (PDF) (Ignoramus?) olcott <NoOne@NoWhere.com> - 2021-03-08 00:10 -0600
Re: Detecting infinite recursion (PDF) (Ignoramus?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-08 07:04 +0000
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-06 21:10 +0000
Re: Detecting infinite recursion (PDF) olcott <NoOne@NoWhere.com> - 2021-03-06 15:43 -0600
Re: Detecting infinite recursion (PDF) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 20:24 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 15:51 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 18:26 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 01:07 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 19:14 -0600
Re: Detecting infinite recursion (halt deciding criteria) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-06 19:16 -0800
Re: Detecting infinite recursion (halt deciding criteria) Jeff Barnett <jbb@notatt.com> - 2021-03-06 11:49 -0700
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-06 10:24 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 22:23 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 16:42 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 01:14 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 19:30 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 01:46 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 20:05 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 02:47 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 21:03 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 11:46 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 08:57 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-05 10:48 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 16:07 +0000
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 21:54 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 21:07 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 22:35 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 21:43 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 23:13 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 23:49 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-05 09:50 -0500
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 22:20 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 16:31 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 01:13 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 19:20 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 02:42 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 21:00 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 12:01 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-05 09:03 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 16:11 +0000
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 10:20 -0600
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-05 11:41 -0500
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 22:06 +0000
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 16:41 -0600
Re: Detecting infinite recursion (halt deciding criteria) [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 16:53 -0600
Re: Detecting infinite recursion (halt deciding criteria) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 01:27 +0000
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 19:43 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 22:04 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 21:17 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 23:00 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-04 22:14 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-05 10:18 -0500
Re: Detecting infinite recursion (halt deciding criteria) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-04 20:03 -0800
Re: Detecting infinite recursion (halt deciding criteria) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-04 20:46 -0800
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 22:33 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 21:43 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 23:08 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 22:15 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 23:30 -0500
Re: Detecting infinite recursion (halt deciding criteria) olcott <NoOne@NoWhere.com> - 2021-03-03 22:35 -0600
Re: Detecting infinite recursion (halt deciding criteria) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 23:56 -0500
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 16:07 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 15:41 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 17:20 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 16:29 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 17:55 -0500
Re: Detecting infinite recursion (exception to the rule) olcott <NoOne@NoWhere.com> - 2021-03-02 16:24 -0600
Re: Detecting infinite recursion (exception to the rule) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 17:50 -0500
Re: Detecting infinite recursion (exception to the rule) olcott <NoOne@NoWhere.com> - 2021-03-02 16:59 -0600
Re: Detecting infinite recursion (exception to the rule) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 19:20 -0500
Re: Detecting infinite recursion (credit where it is due) olcott <NoOne@NoWhere.com> - 2021-03-02 18:45 -0600
Re: Detecting infinite recursion (credit where it is due) Richard Damon <Richard@Damon-Family.org> - 2021-03-02 20:58 -0500
Re: Detecting infinite recursion Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-02 22:57 +0000
Re: Detecting infinite recursion om@iki.fi (Otto J. Makela) - 2021-03-03 14:46 +0200
Re: Detecting infinite recursion Siri Cruise <chine.bleu@yahoo.com> - 2021-03-02 12:04 -0800
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 14:49 -0600
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-02 15:52 -0500
Re: Detecting infinite recursion is simple olcott <NoOne@NoWhere.com> - 2021-03-02 15:08 -0600
Re: Detecting infinite recursion is simple Richard Damon <Richard@Damon-Family.org> - 2021-03-02 17:33 -0500
Re: Detecting infinite recursion is simple olcott <NoOne@NoWhere.com> - 2021-03-02 17:18 -0600
Re: Detecting infinite recursion is simple Richard Damon <Richard@Damon-Family.org> - 2021-03-02 21:07 -0500
Re: Detecting infinite recursion Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-02 21:41 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 15:57 -0600
Re: Detecting infinite recursion Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-02 22:32 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-02 16:42 -0600
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-03 12:52 -0600
Re: Detecting infinite recursion Alan Mackenzie <acm@muc.de> - 2021-03-03 19:53 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-03 14:07 -0600
Re: Detecting infinite recursion Alan Mackenzie <acm@muc.de> - 2021-03-03 21:14 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-03 15:25 -0600
Re: Detecting infinite recursion Alan Mackenzie <acm@muc.de> - 2021-03-03 22:01 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-03 16:09 -0600
Re: Detecting infinite recursion Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-03 22:59 +0000
Re: Detecting infinite recursion Richard Damon <Richard@Damon-Family.org> - 2021-03-03 17:19 -0500
Re: Detecting infinite recursion Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-03 22:50 +0000
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-03 16:56 -0600
Re: Detecting infinite recursion Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-04 01:51 +0000
Re: Detecting infinite recursion (rewritten) olcott <NoOne@NoWhere.com> - 2021-03-03 17:06 -0600
Re: Detecting infinite recursion (rewritten) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 18:17 -0500
Re: Detecting infinite recursion (rewritten) olcott <NoOne@NoWhere.com> - 2021-03-03 17:25 -0600
Re: Detecting infinite recursion (rewritten) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 19:46 -0500
Re: Detecting infinite recursion (rewritten) olcott <NoOne@NoWhere.com> - 2021-03-03 19:09 -0600
Re: Detecting infinite recursion (rewritten) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 22:45 -0500
Re: Detecting infinite recursion (rewritten) olcott <NoOne@NoWhere.com> - 2021-03-03 21:55 -0600
Re: Detecting infinite recursion (rewritten) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 23:11 -0500
Re: Detecting infinite recursion (rewritten) olcott <NoOne@NoWhere.com> - 2021-03-03 22:22 -0600
Re: Detecting infinite recursion (rewritten) Richard Damon <Richard@Damon-Family.org> - 2021-03-03 23:48 -0500
Re: Detecting infinite recursion (rewritten) pointless olcott <NoOne@NoWhere.com> - 2021-03-03 22:59 -0600
Re: Detecting infinite recursion (rewritten) pointless Richard Damon <Richard@Damon-Family.org> - 2021-03-04 07:17 -0500
Re: Detecting infinite recursion (rewritten) pointless olcott <NoOne@NoWhere.com> - 2021-03-04 08:07 -0600
Re: Detecting infinite recursion (rewritten) pointless Richard Damon <Richard@Damon-Family.org> - 2021-03-04 10:11 -0500
Re: Detecting infinite recursion (rewritten) pointless olcott <NoOne@NoWhere.com> - 2021-03-04 09:21 -0600
Re: Detecting infinite recursion (rewritten) pointless Richard Damon <Richard@Damon-Family.org> - 2021-03-04 10:48 -0500
Re: Detecting infinite recursion (rewritten) pointless olcott <NoOne@NoWhere.com> - 2021-03-04 09:55 -0600
Re: Detecting infinite recursion (rewritten) pointless Richard Damon <Richard@Damon-Family.org> - 2021-03-04 11:31 -0500
Re: Detecting infinite recursion (rewritten) pointless Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-04 07:59 -0800
Re: Detecting infinite recursion (rewritten) pointless olcott <NoOne@NoWhere.com> - 2021-03-04 10:12 -0600
Re: Detecting infinite recursion (rewritten) pointless Richard Damon <Richard@Damon-Family.org> - 2021-03-04 11:40 -0500
Re: Detecting infinite recursion olcott <NoOne@NoWhere.com> - 2021-03-03 12:55 -0600
Re: Detecting infinite recursion Bonita Montero <Bonita.Montero@gmail.com> - 2021-03-07 16:38 +0100
Re: Detecting infinite recursion (halting problem) olcott <NoOne@NoWhere.com> - 2021-03-07 09:55 -0600
Re: Detecting infinite recursion (halting problem) Bonita Montero <Bonita.Montero@gmail.com> - 2021-03-07 18:08 +0100
Re: Detecting infinite recursion "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-07 10:54 -0800
Re: Detecting infinite recursion (2021-03-09) olcott <NoOne@NoWhere.com> - 2021-03-09 19:42 -0600
Re: Detecting infinite recursion (2021-03-09) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:22 +0000
Re: Detecting infinite recursion (2021-03-09) olcott <NoOne@NoWhere.com> - 2021-03-09 20:30 -0600
Re: Detecting infinite recursion (2021-03-09) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 21:54 -0500
Re: Detecting infinite recursion (2021-03-09) olcott <NoOne@NoWhere.com> - 2021-03-09 21:01 -0600
Re: Detecting infinite recursion (2021-03-09) Richard Damon <Richard@Damon-Family.org> - 2021-03-09 22:29 -0500
Re: Detecting infinite recursion (2021-03-09) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 03:31 +0000
Re: Detecting infinite recursion (2021-03-09) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 03:15 +0000
Re: Detecting infinite recursion (2021-03-09) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-09 18:31 -0800
Page 4 of 37 — ← Prev page 1 2 3 [4] 5 6 … 37 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 11:42 -0600 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <aYGdnVsay4l25aP9nZ2dnUU7-XvNnZ2d@giganews.com> |
| In reply to | #28241 |
On 3/2/2021 11:01 AM, Richard Damon wrote: > On 3/2/21 10:58 AM, olcott wrote: >> On 3/2/2021 9:55 AM, Richard Damon wrote: >>> On 3/2/21 9:45 AM, olcott wrote: >>>> >>>> Because the execution trace shown below shows that H_Hat() invokes >>>> Simulate() with the same data two times in sequence we can conclude that >>>> H_Hat() is invoked in infinite recursion entirely based on this >>>> execution trace and the assumption that Simulate() does nothing besides >>>> execute or emulate it input. >>> >>> And one IMPORTANT thing to note about this is that this only works >>> BECAUSE Simulate doesn't create a new isolated memory space for the >>> simulation. >>> >>> Which means that Simulation can't be later argued to be 'like' a UTM, >>> because those MUST create a new isoloated memory space. >>> >> >> Go ahead and believe that if you want to. I really don't care. >> > > If you want to claim your cat has wings and can fly, go ahead. > > A Simulator that does not create a new memory space is NOT the > equivalent of a UTM, and nothing you can say will make it one. > > The simple proof of this is to make program A thst uses this simulator > that is defined to load at program address X, and it asks to run a > program B that is also define to load at program address X. > > With your system, such a program can not be built, therefor your 'UTM' > is not Universal. Fail by definition. > Just like an actual UTM all of machine descriptions to be simulated are already on the master UTM tape before the master UTM begins to simulate their execution. When a UTM simulates itself this is analogous to a recursive invocation. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-02 13:05 -0500 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <x7v%H.11284$MT.10593@fx35.iad> |
| In reply to | #28244 |
On 3/2/21 12:42 PM, olcott wrote: > On 3/2/2021 11:01 AM, Richard Damon wrote: >> If you want to claim your cat has wings and can fly, go ahead. >> >> A Simulator that does not create a new memory space is NOT the >> equivalent of a UTM, and nothing you can say will make it one. >> >> The simple proof of this is to make program A thst uses this simulator >> that is defined to load at program address X, and it asks to run a >> program B that is also define to load at program address X. >> >> With your system, such a program can not be built, therefor your 'UTM' >> is not Universal. Fail by definition. >> > > Just like an actual UTM all of machine descriptions to be simulated are > already on the master UTM tape before the master UTM begins to simulate > their execution. When a UTM simulates itself this is analogous to a > recursive invocation. > Wrong. It is totally possible to write a Turing Machine, that includes within it the code for a UTM that before falling into the UTM creates (or maybe just Modify an existing reprentation) on the Tape for the UTM to run. Your configuration can not do this, thus it fails to be the equivalent of a UTM.
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2021-03-03 14:54 +0000 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <FOednQ8qcJmXPqL9nZ2dnUU78V3NnZ2d@brightview.co.uk> |
| In reply to | #28225 |
On 02/03/2021 03:32, olcott wrote:
> On 3/1/2021 9:05 PM, olcott wrote:
>> On 3/1/2021 8:22 PM, Mike Terry wrote:
>>> On 02/03/2021 01:31, olcott wrote:
>>>> On 3/1/2021 7:00 PM, Mike Terry wrote:
>>>>> On 01/03/2021 23:00, olcott wrote:
>>>>>> On 3/1/2021 4:42 PM, Mike Terry wrote:
>>>>>>> On 01/03/2021 20:22, olcott wrote:
>>>>>>>> On 3/1/2021 1:39 PM, Kaz Kylheku wrote:
>>>>>>>>> On 2021-03-01, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 3/1/2021 12:25 PM, Kaz Kylheku wrote:
>>>>>>>>>>> On 2021-03-01, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 3/1/2021 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>> I already acknowledged this. When an equivalent computation
>>>>>>>>>>>> is run on a
>>>>>>>>>>>> machine without resource limits (such as a TM) then this
>>>>>>>>>>>> computation is
>>>>>>>>>>>> infinitely recursive.
>>>>>>>>>>>
>>>>>>>>>>> That depends on what you mean by "equivalent". Since you have
>>>>>>>>>>> tied the
>>>>>>>>>>> validity your work to the x86 representation, a Turing
>>>>>>>>>>> Machine version
>>>>>>>>>>> of your program, to be equivalent, has to contain the x86
>>>>>>>>>>> program, and
>>>>>>>>>>> the simulator, faithfully reproducing the same resource
>>>>>>>>>>> limitations.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> A RASP machine is known to be equivalent to a UTM.
>>>>>>>>>>
>>>>>>>>>> Thus the RASP is to the RAM as the Universal Turing machine is
>>>>>>>>>> to the
>>>>>>>>>> Turing machine. The RASP is an example of the von Neumann
>>>>>>>>>> architecture.
>>>>>>>>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The x86 language is another exapmle of the von Neumann
>>>>>>>>>> architecture.
>>>>>>>>>> All computations implemented using the von Neumann
>>>>>>>>>> architecture are
>>>>>>>>>> equivalent to one another as long as they do not require more
>>>>>>>>>> memory
>>>>>>>>>> than is available.
>>>>>>>>>>
>>>>>>>>>> Thus all computations implemented using the von Neumann
>>>>>>>>>> architecture are
>>>>>>>>>> equivalent UTM computations as long as they do not require
>>>>>>>>>> more memory
>>>>>>>>>> than is available.
>>>>>>>>>
>>>>>>>>> That is true; but an infinite recursion does require
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>> When I say that the x86 emulator: Simulate() is functionally
>>>>>>>>>>>> equivalent
>>>>>>>>>>>> to this code:
>>>>>>>>>>>>
>>>>>>>>>>>> int Simulate(u32 P, u32 I)
>>>>>>>>>>>> {
>>>>>>>>>>>> ((void(*)(int))P)(I);
>>>>>>>>>>>> return 1;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> That is all that need be said about the capabilities of the
>>>>>>>>>>>> x86 emulator.
>>>>>>>>>>>
>>>>>>>>>>> Yes; then clearly, the H_Hat(P, P) call (with the right casts
>>>>>>>>>>> put in)
>>>>>>>>>>> denotes a runaway recursive call.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So we agree on this point?
>>>>>>>>>
>>>>>>>>> Why wouldn't we? It's obviously a runaway recursive call.
>>>>>>>>>
>>>>>>>>>> When we know that Simulate() is an x86 emulator that is
>>>>>>>>>> functionally
>>>>>>>>>> equivalent to direct execution of its input then from the
>>>>>>>>>> execution
>>>>>>>>>> trace of the execution of this input (including the inputs to
>>>>>>>>>> functions
>>>>>>>>>> stored on the stack) alone we can decide that H_Hat() is
>>>>>>>>>> infinitely
>>>>>>>>>> recursive.
>>>>>>>>>
>>>>>>>>> Yes.
>>>>>>>>>
>>>>>>>>> In a static call graph of a program, we can spot loops.
>>>>>>>>>
>>>>>>>>> For instance a simple infinite loop occurs when a basic block
>>>>>>>>> jumps to
>>>>>>>>> itself.
>>>>>>>>>
>>>>>>>>> A basic block has no branching instructions anywhere, except as
>>>>>>>>> possibly
>>>>>>>>> the last instruction. If that last instruction is an
>>>>>>>>> unconditional jump
>>>>>>>>> back to that block, that is an infinite loop.
>>>>>>>>>
>>>>>>>>> Compilers do this kind of control flow analysis to find loops,
>>>>>>>>> where certain optimizations can be concentrated (e.g. giving more
>>>>>>>>> registers to variables in nested loops).
>>>>>>>>>
>>>>>>>>> If we monitor the execution dynamically, we can likewise identify
>>>>>>>>> "dynamic basic blocks" sequences of unconditionally executed
>>>>>>>>> instructions with no branches, and we can detect infinite loops.
>>>>>>>>> (Possibly ones that contain a stack push, if the jump is actually
>>>>>>>>> a subroutine call.)
>>>>>>>>>
>>>>>>>>> If we simply identify the situation, but don't interfere in it,
>>>>>>>>> then the
>>>>>>>>> situation persists: there is runaway recursion.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When this same simulator monitors its own simulation it could
>>>>>>>> figure out that the H_Hat() invocation of itself is infinitely
>>>>>>>> recursive.
>>>>>>>>
>>>>>>>
>>>>>>> I'm afraid that's "wrong-headed" thinking, because Simulate
>>>>>>> simply DOES NOT monitor its own simulation, so you can't talk
>>>>>>> about when it does something IT DOESN'T DO. :) The same mental
>>>>>>> confusion underlies your ".. /would/ fail to terminate /if/
>>>>>>> ABNHBD() didn't abort the emulation", and other anthropomorphisms
>>>>>>> you make for TMs.
>>>>>>>
>>>>>>
>>>>>> So in other words you cannot possibly begin to imagine that a
>>>>>> software function could be adapted to add functionality.
>>>>>>
>>>>>>> /We/ can figure out that the above H_Hat is infinitely recursive,
>>>>>>> but /we/ are not Simulate, so H_Hat is not our "We_hat", and this
>>>>>>> says nothing about the Linz proof.
>>>>>>>
>>>>>>> The /Simulate/ as you've described it (pure emulation) /cannot/
>>>>>>> "figure it out", because it fails to return and so doesn't
>>>>>>> "figure" anything. Again, nothing much to say re HP proof.
>>>>>>>
>>>>>>> We could code a /new/ emulator routine Simulate2 (distinct from
>>>>>>> H_Hat and Simulate above) which has monitoring logic, and use it
>>>>>>> to examine a simulation of the H_Hat above calling
>>>>>>> Simulate(H_Hat) (note: NOT calling Simulate2...), and this
>>>>>>> Simulate2 could correctly decide that H_Hat(H_Hat) does not
>>>>>>> terminate.
>>>>>>>
>>>>>>> But H_Hat is not the "hatted" machine for Simulate2, so this also
>>>>>>> is of little interest. Nobody claims that "no decider can
>>>>>>> correctly decide halting for H_Hat", only that H does not
>>>>>>> correctly decide halting for its own H_Hat.
>>>>>>>
>>>>>>> If we "update" H_Hat so that instead of calling Simulate, it
>>>>>>> calls the new Simulate2, then we have a /new/ program H_Hat2, and
>>>>>>> a /new/ calculation to consider. When H_Hat2 examines the
>>>>>>> calculation H_Hat2(H_Hat2), with H_Hat2 calling Simulate2 etc.,
>>>>>>> then H_Hat2 /*cannot*/ "figure out" that the calculation has
>>>>>>> infinite recursion, BECAUSE IT DOESN'T. It can certainly
>>>>>>> /decide/ that H_Hat2 is infinitely recursive, but that would just
>>>>>>> be Simulate2 deciding incorrectly. All in line with Linz proof.
>>>>>>>
>>>>>>> Remember, Simulate2 is not a "pure emulator" like Simulate, so
>>>>>>> the fact that there may be two nested emulated calls to Simulate2
>>>>>>> with the same argument IS NOT PROOF OF INFINITE RECURSION.
>>>>>>
>>>>>> When Simulate2() is identical to Simulate() in every way except
>>>>>> that it also examines the execution trace of its input to figure
>>>>>> out that its input is calling Simulate2() in infinite recursion
>>>>>> then by logical necessity H_Hat() is still infinitely recursive.
>>>>>
>>>>> ?
>>>>>
>>>>> H_Hat doesn't call Simulate2. Maybe you mean H_Hat2 ?
>>>>>
>>>>> Obviously the /H_Hat/ calculation is "still" infinitely recursive,
>>>>> because that calculation has never changed - by definition it calls
>>>>> Simulate (not Simulate2).
>>>>>
>>>>> Hmm, your phrase "figuring out" isn't a standard CS term - I've
>>>>> guessed it to mean that Simulate2 returns some different rc (not 1)
>>>>> when it detects the nested calls to Simulate2 with the same input
>>>>> data, thus making a different decision to the rc=1 [halts]
>>>>> decision. Maybe you mean something else?
>>>>>
>>>>>
>>>>> Mike.
>>>>>
>>> >
>>>> An x86 emulator could keep track of all of the details of the
>>>> execution trace of any input. If the original Simulate() was adapted
>>>> to have this feature and the names remain the same then H_Hat()
>>>> would invoke this updated version of Simulate() and still be
>>>> infinitely recursive.
>>>
>>> So was my guess right? Does "figuring out" mean that Simulate2
>>> returns some different rc (not 1) when it detects the nested calls to
>>> Simulate2 with the same input data, thus making a different decision
>>> to the rc=1 [halts] decision? All you've done is replace "figuring
>>> out" with "keep track of" which is no better.
>>>
>>>>
>>>> When software engineers add features to existing functions they do
>>>> not change the names.
>>>
>>> What they do is change the versions. But you are not a software
>>> engineer, so maybe you don't know about version numbers.
>>>
>>> Software engineers use version control systems so that if required
>>> they can recreate the software at whatever point in the development
>>> cycle is required, so there will not be confusion over what code is
>>> being used/discussed at any time.
>>>
>>
>> This is the version number of the whole system at that point in time.
>> I worked on defense projects using version control. The function
>> almost always keep their original names and merely acquire additional
>> functionality.
>>
>>> In contrast, /you/ habitually use the same name for different
>>> programs, and different names for the same programs. I suspect this
>>> is because in part your arguments rely on confusing different
>>> programs as being the same thing, in various ways. So it seems to me
>>> that you do this deliberately. This is the exact opposite to how a
>>> software engineer or professional programmer would behave.
>>>
>>
>> There are only three programs that I will be talking about:
>>
>> // P has the machine address of H_Hat()
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Simulate(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
>>
>> That calls Simulate(P, P) and as the conversation progresses will
>> gradually be adapted step-by-step until it becomes Halts(P, P).
>>
>> There will not be any version numbers for Simulate() because
>> Simulate() is merely a conversational convention used to construct
>> complete understanding of Halts() in small incremental steps.
>>
>>
>>> If it is not deliberate, I suggest you just affix versions to the end
>>> of your programs e.g. "H_Hat2" when they change. That's easier than
>>> full versions, e.g. "H_Hat (V2.1.0.0)" and more appropriate for
>>> newsgroup discussions.
>>>
>>>
>>> Mike.
>
> int Simulate_1(u32 P, u32 I);
> Emulates the x86 code pointed to by machine address P with data at
> machine address I.
>
> int Simulate_2(u32 P, u32 I);
> Same as Simulate_1() except keeps track of the execution trace of its
> input including the data passed to any function invocations.
What does "keeps track of" mean? Does Simulate_2 "do" anything with
this tracked data, or is it just (in this version at least) ignored?
Sorry to keep asking, but you seem to be deliberately not answering my
direct question, and I can't see why - it should be trivial to just
answer. (I would guess from the Simulate_3 description it just ignores
the data.)
>
> int Simulate_3(u32 P, u32 I);
> Same as Simulate_2() except examines the saved execution trace
> immediately after emulating each x86 language instruction to determine
> whether or not this input specifies infinite recursion.
What does "determine whether or not" mean? Does Simulate_3 "do"
anything with this determination, or is it just (in this version) ignored?
>
> It should be self-evident that whenever any of these versions is
> substituted into the body of H_Hat() that H_Hat() remains infinitely
> recursive.
So we will have corresponding H_Hat_1, H_Hat_2, H_Hat_3, but their
behaviour depends on clarifying the meanings as questioned above.
>
> It should be self-evident that Simulate_3() can easily determine the
> infinite recursion of H_Hat() on the basis its execution trace.
>
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-03 12:41 -0600 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <G56dnVyRYtzQRaL9nZ2dnUU7-TnNnZ2d@giganews.com> |
| In reply to | #28333 |
On 3/3/2021 8:54 AM, Mike Terry wrote:
> On 02/03/2021 03:32, olcott wrote:
>> On 3/1/2021 9:05 PM, olcott wrote:
>>> On 3/1/2021 8:22 PM, Mike Terry wrote:
>>>> On 02/03/2021 01:31, olcott wrote:
>>>>> On 3/1/2021 7:00 PM, Mike Terry wrote:
>>>>>> On 01/03/2021 23:00, olcott wrote:
>>>>>>> On 3/1/2021 4:42 PM, Mike Terry wrote:
>>>>>>>> On 01/03/2021 20:22, olcott wrote:
>>>>>>>>> On 3/1/2021 1:39 PM, Kaz Kylheku wrote:
>>>>>>>>>> On 2021-03-01, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> On 3/1/2021 12:25 PM, Kaz Kylheku wrote:
>>>>>>>>>>>> On 2021-03-01, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>> On 3/1/2021 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>> I already acknowledged this. When an equivalent computation
>>>>>>>>>>>>> is run on a
>>>>>>>>>>>>> machine without resource limits (such as a TM) then this
>>>>>>>>>>>>> computation is
>>>>>>>>>>>>> infinitely recursive.
>>>>>>>>>>>>
>>>>>>>>>>>> That depends on what you mean by "equivalent". Since you
>>>>>>>>>>>> have tied the
>>>>>>>>>>>> validity your work to the x86 representation, a Turing
>>>>>>>>>>>> Machine version
>>>>>>>>>>>> of your program, to be equivalent, has to contain the x86
>>>>>>>>>>>> program, and
>>>>>>>>>>>> the simulator, faithfully reproducing the same resource
>>>>>>>>>>>> limitations.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> A RASP machine is known to be equivalent to a UTM.
>>>>>>>>>>>
>>>>>>>>>>> Thus the RASP is to the RAM as the Universal Turing machine
>>>>>>>>>>> is to the
>>>>>>>>>>> Turing machine. The RASP is an example of the von Neumann
>>>>>>>>>>> architecture.
>>>>>>>>>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The x86 language is another exapmle of the von Neumann
>>>>>>>>>>> architecture.
>>>>>>>>>>> All computations implemented using the von Neumann
>>>>>>>>>>> architecture are
>>>>>>>>>>> equivalent to one another as long as they do not require more
>>>>>>>>>>> memory
>>>>>>>>>>> than is available.
>>>>>>>>>>>
>>>>>>>>>>> Thus all computations implemented using the von Neumann
>>>>>>>>>>> architecture are
>>>>>>>>>>> equivalent UTM computations as long as they do not require
>>>>>>>>>>> more memory
>>>>>>>>>>> than is available.
>>>>>>>>>>
>>>>>>>>>> That is true; but an infinite recursion does require
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>> When I say that the x86 emulator: Simulate() is
>>>>>>>>>>>>> functionally equivalent
>>>>>>>>>>>>> to this code:
>>>>>>>>>>>>>
>>>>>>>>>>>>> int Simulate(u32 P, u32 I)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> ((void(*)(int))P)(I);
>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is all that need be said about the capabilities of the
>>>>>>>>>>>>> x86 emulator.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes; then clearly, the H_Hat(P, P) call (with the right
>>>>>>>>>>>> casts put in)
>>>>>>>>>>>> denotes a runaway recursive call.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So we agree on this point?
>>>>>>>>>>
>>>>>>>>>> Why wouldn't we? It's obviously a runaway recursive call.
>>>>>>>>>>
>>>>>>>>>>> When we know that Simulate() is an x86 emulator that is
>>>>>>>>>>> functionally
>>>>>>>>>>> equivalent to direct execution of its input then from the
>>>>>>>>>>> execution
>>>>>>>>>>> trace of the execution of this input (including the inputs to
>>>>>>>>>>> functions
>>>>>>>>>>> stored on the stack) alone we can decide that H_Hat() is
>>>>>>>>>>> infinitely
>>>>>>>>>>> recursive.
>>>>>>>>>>
>>>>>>>>>> Yes.
>>>>>>>>>>
>>>>>>>>>> In a static call graph of a program, we can spot loops.
>>>>>>>>>>
>>>>>>>>>> For instance a simple infinite loop occurs when a basic block
>>>>>>>>>> jumps to
>>>>>>>>>> itself.
>>>>>>>>>>
>>>>>>>>>> A basic block has no branching instructions anywhere, except
>>>>>>>>>> as possibly
>>>>>>>>>> the last instruction. If that last instruction is an
>>>>>>>>>> unconditional jump
>>>>>>>>>> back to that block, that is an infinite loop.
>>>>>>>>>>
>>>>>>>>>> Compilers do this kind of control flow analysis to find loops,
>>>>>>>>>> where certain optimizations can be concentrated (e.g. giving more
>>>>>>>>>> registers to variables in nested loops).
>>>>>>>>>>
>>>>>>>>>> If we monitor the execution dynamically, we can likewise identify
>>>>>>>>>> "dynamic basic blocks" sequences of unconditionally executed
>>>>>>>>>> instructions with no branches, and we can detect infinite loops.
>>>>>>>>>> (Possibly ones that contain a stack push, if the jump is actually
>>>>>>>>>> a subroutine call.)
>>>>>>>>>>
>>>>>>>>>> If we simply identify the situation, but don't interfere in
>>>>>>>>>> it, then the
>>>>>>>>>> situation persists: there is runaway recursion.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When this same simulator monitors its own simulation it could
>>>>>>>>> figure out that the H_Hat() invocation of itself is infinitely
>>>>>>>>> recursive.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I'm afraid that's "wrong-headed" thinking, because Simulate
>>>>>>>> simply DOES NOT monitor its own simulation, so you can't talk
>>>>>>>> about when it does something IT DOESN'T DO. :) The same mental
>>>>>>>> confusion underlies your ".. /would/ fail to terminate /if/
>>>>>>>> ABNHBD() didn't abort the emulation", and other
>>>>>>>> anthropomorphisms you make for TMs.
>>>>>>>>
>>>>>>>
>>>>>>> So in other words you cannot possibly begin to imagine that a
>>>>>>> software function could be adapted to add functionality.
>>>>>>>
>>>>>>>> /We/ can figure out that the above H_Hat is infinitely
>>>>>>>> recursive, but /we/ are not Simulate, so H_Hat is not our
>>>>>>>> "We_hat", and this says nothing about the Linz proof.
>>>>>>>>
>>>>>>>> The /Simulate/ as you've described it (pure emulation) /cannot/
>>>>>>>> "figure it out", because it fails to return and so doesn't
>>>>>>>> "figure" anything. Again, nothing much to say re HP proof.
>>>>>>>>
>>>>>>>> We could code a /new/ emulator routine Simulate2 (distinct from
>>>>>>>> H_Hat and Simulate above) which has monitoring logic, and use it
>>>>>>>> to examine a simulation of the H_Hat above calling
>>>>>>>> Simulate(H_Hat) (note: NOT calling Simulate2...), and this
>>>>>>>> Simulate2 could correctly decide that H_Hat(H_Hat) does not
>>>>>>>> terminate.
>>>>>>>>
>>>>>>>> But H_Hat is not the "hatted" machine for Simulate2, so this
>>>>>>>> also is of little interest. Nobody claims that "no decider can
>>>>>>>> correctly decide halting for H_Hat", only that H does not
>>>>>>>> correctly decide halting for its own H_Hat.
>>>>>>>>
>>>>>>>> If we "update" H_Hat so that instead of calling Simulate, it
>>>>>>>> calls the new Simulate2, then we have a /new/ program H_Hat2,
>>>>>>>> and a /new/ calculation to consider. When H_Hat2 examines the
>>>>>>>> calculation H_Hat2(H_Hat2), with H_Hat2 calling Simulate2 etc.,
>>>>>>>> then H_Hat2 /*cannot*/ "figure out" that the calculation has
>>>>>>>> infinite recursion, BECAUSE IT DOESN'T. It can certainly
>>>>>>>> /decide/ that H_Hat2 is infinitely recursive, but that would
>>>>>>>> just be Simulate2 deciding incorrectly. All in line with Linz
>>>>>>>> proof.
>>>>>>>>
>>>>>>>> Remember, Simulate2 is not a "pure emulator" like Simulate, so
>>>>>>>> the fact that there may be two nested emulated calls to
>>>>>>>> Simulate2 with the same argument IS NOT PROOF OF INFINITE
>>>>>>>> RECURSION.
>>>>>>>
>>>>>>> When Simulate2() is identical to Simulate() in every way except
>>>>>>> that it also examines the execution trace of its input to figure
>>>>>>> out that its input is calling Simulate2() in infinite recursion
>>>>>>> then by logical necessity H_Hat() is still infinitely recursive.
>>>>>>
>>>>>> ?
>>>>>>
>>>>>> H_Hat doesn't call Simulate2. Maybe you mean H_Hat2 ?
>>>>>>
>>>>>> Obviously the /H_Hat/ calculation is "still" infinitely recursive,
>>>>>> because that calculation has never changed - by definition it
>>>>>> calls Simulate (not Simulate2).
>>>>>>
>>>>>> Hmm, your phrase "figuring out" isn't a standard CS term - I've
>>>>>> guessed it to mean that Simulate2 returns some different rc (not
>>>>>> 1) when it detects the nested calls to Simulate2 with the same
>>>>>> input data, thus making a different decision to the rc=1 [halts]
>>>>>> decision. Maybe you mean something else?
>>>>>>
>>>>>>
>>>>>> Mike.
>>>>>>
>>>> >
>>>>> An x86 emulator could keep track of all of the details of the
>>>>> execution trace of any input. If the original Simulate() was
>>>>> adapted to have this feature and the names remain the same then
>>>>> H_Hat() would invoke this updated version of Simulate() and still
>>>>> be infinitely recursive.
>>>>
>>>> So was my guess right? Does "figuring out" mean that Simulate2
>>>> returns some different rc (not 1) when it detects the nested calls
>>>> to Simulate2 with the same input data, thus making a different
>>>> decision to the rc=1 [halts] decision? All you've done is replace
>>>> "figuring out" with "keep track of" which is no better.
>>>>
>>>>>
>>>>> When software engineers add features to existing functions they do
>>>>> not change the names.
>>>>
>>>> What they do is change the versions. But you are not a software
>>>> engineer, so maybe you don't know about version numbers.
>>>>
>>>> Software engineers use version control systems so that if required
>>>> they can recreate the software at whatever point in the development
>>>> cycle is required, so there will not be confusion over what code is
>>>> being used/discussed at any time.
>>>>
>>>
>>> This is the version number of the whole system at that point in time.
>>> I worked on defense projects using version control. The function
>>> almost always keep their original names and merely acquire additional
>>> functionality.
>>>
>>>> In contrast, /you/ habitually use the same name for different
>>>> programs, and different names for the same programs. I suspect this
>>>> is because in part your arguments rely on confusing different
>>>> programs as being the same thing, in various ways. So it seems to
>>>> me that you do this deliberately. This is the exact opposite to how
>>>> a software engineer or professional programmer would behave.
>>>>
>>>
>>> There are only three programs that I will be talking about:
>>>
>>> // P has the machine address of H_Hat()
>>> void H_Hat(u32 P)
>>> {
>>> u32 Input_Halts = Simulate(P, P);
>>> if (Input_Halts)
>>> HERE: goto HERE;
>>> return;
>>> }
>>>
>>> That calls Simulate(P, P) and as the conversation progresses will
>>> gradually be adapted step-by-step until it becomes Halts(P, P).
>>>
>>> There will not be any version numbers for Simulate() because
>>> Simulate() is merely a conversational convention used to construct
>>> complete understanding of Halts() in small incremental steps.
>>>
>>>
>>>> If it is not deliberate, I suggest you just affix versions to the
>>>> end of your programs e.g. "H_Hat2" when they change. That's easier
>>>> than full versions, e.g. "H_Hat (V2.1.0.0)" and more appropriate for
>>>> newsgroup discussions.
>>>>
>>>>
>>>> Mike.
>>
>> int Simulate_1(u32 P, u32 I);
>> Emulates the x86 code pointed to by machine address P with data at
>> machine address I.
>>
>> int Simulate_2(u32 P, u32 I);
>> Same as Simulate_1() except keeps track of the execution trace of its
>> input including the data passed to any function invocations.
>
> What does "keeps track of" mean? Does Simulate_2 "do" anything with
> this tracked data, or is it just (in this version at least) ignored?
>
> Sorry to keep asking, but you seem to be deliberately not answering my
> direct question, and I can't see why - it should be trivial to just
> answer. (I would guess from the Simulate_3 description it just ignores
> the data.)
>
>>
>> int Simulate_3(u32 P, u32 I);
>> Same as Simulate_2() except examines the saved execution trace
>> immediately after emulating each x86 language instruction to determine
>> whether or not this input specifies infinite recursion.
>
> What does "determine whether or not" mean? Does Simulate_3 "do"
> anything with this determination, or is it just (in this version) ignored?
>
>>
>> It should be self-evident that whenever any of these versions is
>> substituted into the body of H_Hat() that H_Hat() remains infinitely
>> recursive.
>
> So we will have corresponding H_Hat_1, H_Hat_2, H_Hat_3, but their
> behaviour depends on clarifying the meanings as questioned above.
>
>>
>> It should be self-evident that Simulate_3() can easily determine the
>> infinite recursion of H_Hat() on the basis its execution trace.
>>
>
> Mike.
>
u32 Halts(u32 P, u32 I)
{
((void(*)(int))P)(I);
return 1;
}
// P has the machine address of H_Hat()
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt = ", Input_Would_Halt);
}
Because the execution trace shown below shows that H_Hat() invokes
Halts() with the same data two times in sequence we can conclude that
H_Hat() is invoked in infinite recursion entirely based on the execution
trace of H_Hat() and the assumption that Halts() does nothing besides
execute or emulate its input.
When Halts() is augmented so that it can see that H_Hat() invokes it two
times in sequence with the same data (entirely on the basis of the
execution trace shown below) then Halts() can determine that H_Hat() is
infinitely recursive. Halts examines the x86 machine language, this
column has been removed to make the table simpler.
_Halts()
[000004af](01) 55 push ebp
[000004b0](02) 8bec mov ebp,esp
[000004b2](03) 8b450c mov eax,[ebp+0c]
[000004b5](01) 50 push eax
[000004b6](03) ff5508 call dword [ebp+08]
[000004b9](03) 83c404 add esp,+04
[000004bc](05) b801000000 mov eax,00000001
[000004c1](01) 5d pop ebp
[000004c2](01) c3 ret
_H_Hat()
[0000088f](01) 55 push ebp
[00000890](02) 8bec mov ebp,esp
[00000892](01) 51 push ecx
[00000893](03) 8b4508 mov eax,[ebp+08]
[00000896](01) 50 push eax ; 2nd Param
[00000897](03) 8b4d08 mov ecx,[ebp+08]
[0000089a](01) 51 push ecx ; 1st Param
[0000089b](05) e80ffcffff call 000004af ; Halts(P,P)
[000008a0](03) 83c408 add esp,+08
[000008a3](03) 8945fc mov [ebp-04],eax
[000008a6](04) 837dfc00 cmp dword [ebp-04],+00
[000008aa](02) 7402 jz 000008ae
[000008ac](02) ebfe jmp 000008ac
[000008ae](02) 8be5 mov esp,ebp
[000008b0](01) 5d pop ebp
[000008b1](01) c3 ret
_main()
[000008bf](01) 55 push ebp
[000008c0](02) 8bec mov ebp,esp
[000008c2](01) 51 push ecx
[000008c3](05) 688f080000 push 0000088f
[000008c8](05) 688f080000 push 0000088f
[000008cd](05) e8ddfbffff call 000004af
[000008d2](03) 83c408 add esp,+08
[000008d5](03) 8945fc mov [ebp-04],eax
[000008d8](03) 8b45fc mov eax,[ebp-04]
[000008db](01) 50 push eax
[000008dc](05) 680b030000 push 0000030b
[000008e1](05) e869faffff call 0000034f
[000008e6](03) 83c408 add esp,+08
[000008e9](02) 33c0 xor eax,eax
[000008eb](02) 8be5 mov esp,ebp
[000008ed](01) 5d pop ebp
[000008ee](01) c3 ret
Push instructions have already pushed the value shown in their in the
third column. The two push instructions preceding the call to Simulate()
are its second and first parameters respectively.
Columns
(1) Machine address of instruction
(2) Machine address of top of stack
(3) Value of top of stack after instruction executed
(4) Assembly language text
[000008bf][00011208][00000000] push ebp
[000008c0][00011208][00000000] mov ebp,esp
[000008c2][00011204][00000000] push ecx
[000008c3][00011200][0000088f] push 0000088f
[000008c8][000111fc][0000088f] push 0000088f
[000008cd][000111f8][000008d2] call 000004af
[0000088f][000111e8][000111f4] push ebp
[00000890][000111e8][000111f4] mov ebp,esp
[00000892][000111e4][00000000] push ecx
[00000893][000111e4][00000000] mov eax,[ebp+08]
[00000896][000111e0][0000088f] push eax ; 2nd Param
[00000897][000111e0][0000088f] mov ecx,[ebp+08]
[0000089a][000111dc][0000088f] push ecx ; 1st Param
Call Halts(0000088f, 0000088f);
[0000089b][000111d8][000008a0] call 000004af ; Call Halts(88f, 88f);
[0000088f][000111c8][000111d4] push ebp
[00000890][000111c8][000111d4] mov ebp,esp
[00000892][000111c4][0000088f] push ecx
[00000893][000111c4][0000088f] mov eax,[ebp+08]
[00000896][000111c0][0000088f] push eax ; 2nd Param
[00000897][000111c0][0000088f] mov ecx,[ebp+08]
[0000089a][000111bc][0000088f] push ecx ;1st Param
Call Halts(0000088f, 0000088f);
[0000089b][000111b8][000008a0] call 000004af ;Call Halts(88f, 88f);
On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
> A computation that would not halt if its simulation were not
> halted is indeed a non-halting computation.
Therefore as soon as Halts() determines that its input would not halt
unless Halts() stopped simulating this input it can stop simulating this
input and decide not halting.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2021-03-03 21:13 +0000 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <07-dnbuspaFlZqL9nZ2dnUU78b3NnZ2d@brightview.co.uk> |
| In reply to | #28338 |
On 03/03/2021 18:41, olcott wrote:
> On 3/3/2021 8:54 AM, Mike Terry wrote:
>> On 02/03/2021 03:32, olcott wrote:
>>> On 3/1/2021 9:05 PM, olcott wrote:
>>>> On 3/1/2021 8:22 PM, Mike Terry wrote:
>>>>> On 02/03/2021 01:31, olcott wrote:
>>>>>> On 3/1/2021 7:00 PM, Mike Terry wrote:
>>>>>>> On 01/03/2021 23:00, olcott wrote:
>>>>>>>> On 3/1/2021 4:42 PM, Mike Terry wrote:
>>>>>>>>> On 01/03/2021 20:22, olcott wrote:
>>>>>>>>>> On 3/1/2021 1:39 PM, Kaz Kylheku wrote:
>>>>>>>>>>> On 2021-03-01, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 3/1/2021 12:25 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>> On 2021-03-01, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>> On 3/1/2021 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>> I already acknowledged this. When an equivalent
>>>>>>>>>>>>>> computation is run on a
>>>>>>>>>>>>>> machine without resource limits (such as a TM) then this
>>>>>>>>>>>>>> computation is
>>>>>>>>>>>>>> infinitely recursive.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That depends on what you mean by "equivalent". Since you
>>>>>>>>>>>>> have tied the
>>>>>>>>>>>>> validity your work to the x86 representation, a Turing
>>>>>>>>>>>>> Machine version
>>>>>>>>>>>>> of your program, to be equivalent, has to contain the x86
>>>>>>>>>>>>> program, and
>>>>>>>>>>>>> the simulator, faithfully reproducing the same resource
>>>>>>>>>>>>> limitations.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> A RASP machine is known to be equivalent to a UTM.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus the RASP is to the RAM as the Universal Turing machine
>>>>>>>>>>>> is to the
>>>>>>>>>>>> Turing machine. The RASP is an example of the von Neumann
>>>>>>>>>>>> architecture.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The x86 language is another exapmle of the von Neumann
>>>>>>>>>>>> architecture.
>>>>>>>>>>>> All computations implemented using the von Neumann
>>>>>>>>>>>> architecture are
>>>>>>>>>>>> equivalent to one another as long as they do not require
>>>>>>>>>>>> more memory
>>>>>>>>>>>> than is available.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus all computations implemented using the von Neumann
>>>>>>>>>>>> architecture are
>>>>>>>>>>>> equivalent UTM computations as long as they do not require
>>>>>>>>>>>> more memory
>>>>>>>>>>>> than is available.
>>>>>>>>>>>
>>>>>>>>>>> That is true; but an infinite recursion does require
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>> When I say that the x86 emulator: Simulate() is
>>>>>>>>>>>>>> functionally equivalent
>>>>>>>>>>>>>> to this code:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int Simulate(u32 P, u32 I)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> ((void(*)(int))P)(I);
>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is all that need be said about the capabilities of
>>>>>>>>>>>>>> the x86 emulator.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes; then clearly, the H_Hat(P, P) call (with the right
>>>>>>>>>>>>> casts put in)
>>>>>>>>>>>>> denotes a runaway recursive call.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So we agree on this point?
>>>>>>>>>>>
>>>>>>>>>>> Why wouldn't we? It's obviously a runaway recursive call.
>>>>>>>>>>>
>>>>>>>>>>>> When we know that Simulate() is an x86 emulator that is
>>>>>>>>>>>> functionally
>>>>>>>>>>>> equivalent to direct execution of its input then from the
>>>>>>>>>>>> execution
>>>>>>>>>>>> trace of the execution of this input (including the inputs
>>>>>>>>>>>> to functions
>>>>>>>>>>>> stored on the stack) alone we can decide that H_Hat() is
>>>>>>>>>>>> infinitely
>>>>>>>>>>>> recursive.
>>>>>>>>>>>
>>>>>>>>>>> Yes.
>>>>>>>>>>>
>>>>>>>>>>> In a static call graph of a program, we can spot loops.
>>>>>>>>>>>
>>>>>>>>>>> For instance a simple infinite loop occurs when a basic block
>>>>>>>>>>> jumps to
>>>>>>>>>>> itself.
>>>>>>>>>>>
>>>>>>>>>>> A basic block has no branching instructions anywhere, except
>>>>>>>>>>> as possibly
>>>>>>>>>>> the last instruction. If that last instruction is an
>>>>>>>>>>> unconditional jump
>>>>>>>>>>> back to that block, that is an infinite loop.
>>>>>>>>>>>
>>>>>>>>>>> Compilers do this kind of control flow analysis to find loops,
>>>>>>>>>>> where certain optimizations can be concentrated (e.g. giving
>>>>>>>>>>> more
>>>>>>>>>>> registers to variables in nested loops).
>>>>>>>>>>>
>>>>>>>>>>> If we monitor the execution dynamically, we can likewise
>>>>>>>>>>> identify
>>>>>>>>>>> "dynamic basic blocks" sequences of unconditionally executed
>>>>>>>>>>> instructions with no branches, and we can detect infinite loops.
>>>>>>>>>>> (Possibly ones that contain a stack push, if the jump is
>>>>>>>>>>> actually
>>>>>>>>>>> a subroutine call.)
>>>>>>>>>>>
>>>>>>>>>>> If we simply identify the situation, but don't interfere in
>>>>>>>>>>> it, then the
>>>>>>>>>>> situation persists: there is runaway recursion.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When this same simulator monitors its own simulation it could
>>>>>>>>>> figure out that the H_Hat() invocation of itself is infinitely
>>>>>>>>>> recursive.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I'm afraid that's "wrong-headed" thinking, because Simulate
>>>>>>>>> simply DOES NOT monitor its own simulation, so you can't talk
>>>>>>>>> about when it does something IT DOESN'T DO. :) The same mental
>>>>>>>>> confusion underlies your ".. /would/ fail to terminate /if/
>>>>>>>>> ABNHBD() didn't abort the emulation", and other
>>>>>>>>> anthropomorphisms you make for TMs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So in other words you cannot possibly begin to imagine that a
>>>>>>>> software function could be adapted to add functionality.
>>>>>>>>
>>>>>>>>> /We/ can figure out that the above H_Hat is infinitely
>>>>>>>>> recursive, but /we/ are not Simulate, so H_Hat is not our
>>>>>>>>> "We_hat", and this says nothing about the Linz proof.
>>>>>>>>>
>>>>>>>>> The /Simulate/ as you've described it (pure emulation) /cannot/
>>>>>>>>> "figure it out", because it fails to return and so doesn't
>>>>>>>>> "figure" anything. Again, nothing much to say re HP proof.
>>>>>>>>>
>>>>>>>>> We could code a /new/ emulator routine Simulate2 (distinct from
>>>>>>>>> H_Hat and Simulate above) which has monitoring logic, and use
>>>>>>>>> it to examine a simulation of the H_Hat above calling
>>>>>>>>> Simulate(H_Hat) (note: NOT calling Simulate2...), and this
>>>>>>>>> Simulate2 could correctly decide that H_Hat(H_Hat) does not
>>>>>>>>> terminate.
>>>>>>>>>
>>>>>>>>> But H_Hat is not the "hatted" machine for Simulate2, so this
>>>>>>>>> also is of little interest. Nobody claims that "no decider can
>>>>>>>>> correctly decide halting for H_Hat", only that H does not
>>>>>>>>> correctly decide halting for its own H_Hat.
>>>>>>>>>
>>>>>>>>> If we "update" H_Hat so that instead of calling Simulate, it
>>>>>>>>> calls the new Simulate2, then we have a /new/ program H_Hat2,
>>>>>>>>> and a /new/ calculation to consider. When H_Hat2 examines the
>>>>>>>>> calculation H_Hat2(H_Hat2), with H_Hat2 calling Simulate2 etc.,
>>>>>>>>> then H_Hat2 /*cannot*/ "figure out" that the calculation has
>>>>>>>>> infinite recursion, BECAUSE IT DOESN'T. It can certainly
>>>>>>>>> /decide/ that H_Hat2 is infinitely recursive, but that would
>>>>>>>>> just be Simulate2 deciding incorrectly. All in line with Linz
>>>>>>>>> proof.
>>>>>>>>>
>>>>>>>>> Remember, Simulate2 is not a "pure emulator" like Simulate, so
>>>>>>>>> the fact that there may be two nested emulated calls to
>>>>>>>>> Simulate2 with the same argument IS NOT PROOF OF INFINITE
>>>>>>>>> RECURSION.
>>>>>>>>
>>>>>>>> When Simulate2() is identical to Simulate() in every way except
>>>>>>>> that it also examines the execution trace of its input to figure
>>>>>>>> out that its input is calling Simulate2() in infinite recursion
>>>>>>>> then by logical necessity H_Hat() is still infinitely recursive.
>>>>>>>
>>>>>>> ?
>>>>>>>
>>>>>>> H_Hat doesn't call Simulate2. Maybe you mean H_Hat2 ?
>>>>>>>
>>>>>>> Obviously the /H_Hat/ calculation is "still" infinitely
>>>>>>> recursive, because that calculation has never changed - by
>>>>>>> definition it calls Simulate (not Simulate2).
>>>>>>>
>>>>>>> Hmm, your phrase "figuring out" isn't a standard CS term - I've
>>>>>>> guessed it to mean that Simulate2 returns some different rc (not
>>>>>>> 1) when it detects the nested calls to Simulate2 with the same
>>>>>>> input data, thus making a different decision to the rc=1 [halts]
>>>>>>> decision. Maybe you mean something else?
>>>>>>>
>>>>>>>
>>>>>>> Mike.
>>>>>>>
>>>>> >
>>>>>> An x86 emulator could keep track of all of the details of the
>>>>>> execution trace of any input. If the original Simulate() was
>>>>>> adapted to have this feature and the names remain the same then
>>>>>> H_Hat() would invoke this updated version of Simulate() and still
>>>>>> be infinitely recursive.
>>>>>
>>>>> So was my guess right? Does "figuring out" mean that Simulate2
>>>>> returns some different rc (not 1) when it detects the nested calls
>>>>> to Simulate2 with the same input data, thus making a different
>>>>> decision to the rc=1 [halts] decision? All you've done is replace
>>>>> "figuring out" with "keep track of" which is no better.
>>>>>
>>>>>>
>>>>>> When software engineers add features to existing functions they do
>>>>>> not change the names.
>>>>>
>>>>> What they do is change the versions. But you are not a software
>>>>> engineer, so maybe you don't know about version numbers.
>>>>>
>>>>> Software engineers use version control systems so that if required
>>>>> they can recreate the software at whatever point in the development
>>>>> cycle is required, so there will not be confusion over what code is
>>>>> being used/discussed at any time.
>>>>>
>>>>
>>>> This is the version number of the whole system at that point in
>>>> time. I worked on defense projects using version control. The
>>>> function almost always keep their original names and merely acquire
>>>> additional functionality.
>>>>
>>>>> In contrast, /you/ habitually use the same name for different
>>>>> programs, and different names for the same programs. I suspect
>>>>> this is because in part your arguments rely on confusing different
>>>>> programs as being the same thing, in various ways. So it seems to
>>>>> me that you do this deliberately. This is the exact opposite to
>>>>> how a software engineer or professional programmer would behave.
>>>>>
>>>>
>>>> There are only three programs that I will be talking about:
>>>>
>>>> // P has the machine address of H_Hat()
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Input_Halts = Simulate(P, P);
>>>> if (Input_Halts)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> That calls Simulate(P, P) and as the conversation progresses will
>>>> gradually be adapted step-by-step until it becomes Halts(P, P).
>>>>
>>>> There will not be any version numbers for Simulate() because
>>>> Simulate() is merely a conversational convention used to construct
>>>> complete understanding of Halts() in small incremental steps.
>>>>
>>>>
>>>>> If it is not deliberate, I suggest you just affix versions to the
>>>>> end of your programs e.g. "H_Hat2" when they change. That's easier
>>>>> than full versions, e.g. "H_Hat (V2.1.0.0)" and more appropriate
>>>>> for newsgroup discussions.
>>>>>
>>>>>
>>>>> Mike.
>>>
>>> int Simulate_1(u32 P, u32 I);
>>> Emulates the x86 code pointed to by machine address P with data at
>>> machine address I.
>>>
>>> int Simulate_2(u32 P, u32 I);
>>> Same as Simulate_1() except keeps track of the execution trace of its
>>> input including the data passed to any function invocations.
>>
>> What does "keeps track of" mean? Does Simulate_2 "do" anything with
>> this tracked data, or is it just (in this version at least) ignored?
>>
>> Sorry to keep asking, but you seem to be deliberately not answering my
>> direct question, and I can't see why - it should be trivial to just
>> answer. (I would guess from the Simulate_3 description it just
>> ignores the data.)
>>
<..skip non-responsive answer..>
ok, so you're doing this deliberately. No point continuing...
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-03 15:37 -0600 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <5N2dnX-6zfkwnN39nZ2dnUU7-K3NnZ2d@giganews.com> |
| In reply to | #28345 |
On 3/3/2021 3:13 PM, Mike Terry wrote:
> On 03/03/2021 18:41, olcott wrote:
>> On 3/3/2021 8:54 AM, Mike Terry wrote:
>>> On 02/03/2021 03:32, olcott wrote:
>>>> On 3/1/2021 9:05 PM, olcott wrote:
>>>>> On 3/1/2021 8:22 PM, Mike Terry wrote:
>>>>>> On 02/03/2021 01:31, olcott wrote:
>>>>>>> On 3/1/2021 7:00 PM, Mike Terry wrote:
>>>>>>>> On 01/03/2021 23:00, olcott wrote:
>>>>>>>>> On 3/1/2021 4:42 PM, Mike Terry wrote:
>>>>>>>>>> On 01/03/2021 20:22, olcott wrote:
>>>>>>>>>>> On 3/1/2021 1:39 PM, Kaz Kylheku wrote:
>>>>>>>>>>>> On 2021-03-01, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>> On 3/1/2021 12:25 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>> On 2021-03-01, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>> On 3/1/2021 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>> I already acknowledged this. When an equivalent
>>>>>>>>>>>>>>> computation is run on a
>>>>>>>>>>>>>>> machine without resource limits (such as a TM) then this
>>>>>>>>>>>>>>> computation is
>>>>>>>>>>>>>>> infinitely recursive.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That depends on what you mean by "equivalent". Since you
>>>>>>>>>>>>>> have tied the
>>>>>>>>>>>>>> validity your work to the x86 representation, a Turing
>>>>>>>>>>>>>> Machine version
>>>>>>>>>>>>>> of your program, to be equivalent, has to contain the x86
>>>>>>>>>>>>>> program, and
>>>>>>>>>>>>>> the simulator, faithfully reproducing the same resource
>>>>>>>>>>>>>> limitations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> A RASP machine is known to be equivalent to a UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus the RASP is to the RAM as the Universal Turing machine
>>>>>>>>>>>>> is to the
>>>>>>>>>>>>> Turing machine. The RASP is an example of the von Neumann
>>>>>>>>>>>>> architecture.
>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The x86 language is another exapmle of the von Neumann
>>>>>>>>>>>>> architecture.
>>>>>>>>>>>>> All computations implemented using the von Neumann
>>>>>>>>>>>>> architecture are
>>>>>>>>>>>>> equivalent to one another as long as they do not require
>>>>>>>>>>>>> more memory
>>>>>>>>>>>>> than is available.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus all computations implemented using the von Neumann
>>>>>>>>>>>>> architecture are
>>>>>>>>>>>>> equivalent UTM computations as long as they do not require
>>>>>>>>>>>>> more memory
>>>>>>>>>>>>> than is available.
>>>>>>>>>>>>
>>>>>>>>>>>> That is true; but an infinite recursion does require
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When I say that the x86 emulator: Simulate() is
>>>>>>>>>>>>>>> functionally equivalent
>>>>>>>>>>>>>>> to this code:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int Simulate(u32 P, u32 I)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> ((void(*)(int))P)(I);
>>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is all that need be said about the capabilities of
>>>>>>>>>>>>>>> the x86 emulator.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes; then clearly, the H_Hat(P, P) call (with the right
>>>>>>>>>>>>>> casts put in)
>>>>>>>>>>>>>> denotes a runaway recursive call.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So we agree on this point?
>>>>>>>>>>>>
>>>>>>>>>>>> Why wouldn't we? It's obviously a runaway recursive call.
>>>>>>>>>>>>
>>>>>>>>>>>>> When we know that Simulate() is an x86 emulator that is
>>>>>>>>>>>>> functionally
>>>>>>>>>>>>> equivalent to direct execution of its input then from the
>>>>>>>>>>>>> execution
>>>>>>>>>>>>> trace of the execution of this input (including the inputs
>>>>>>>>>>>>> to functions
>>>>>>>>>>>>> stored on the stack) alone we can decide that H_Hat() is
>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>> recursive.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes.
>>>>>>>>>>>>
>>>>>>>>>>>> In a static call graph of a program, we can spot loops.
>>>>>>>>>>>>
>>>>>>>>>>>> For instance a simple infinite loop occurs when a basic
>>>>>>>>>>>> block jumps to
>>>>>>>>>>>> itself.
>>>>>>>>>>>>
>>>>>>>>>>>> A basic block has no branching instructions anywhere, except
>>>>>>>>>>>> as possibly
>>>>>>>>>>>> the last instruction. If that last instruction is an
>>>>>>>>>>>> unconditional jump
>>>>>>>>>>>> back to that block, that is an infinite loop.
>>>>>>>>>>>>
>>>>>>>>>>>> Compilers do this kind of control flow analysis to find loops,
>>>>>>>>>>>> where certain optimizations can be concentrated (e.g. giving
>>>>>>>>>>>> more
>>>>>>>>>>>> registers to variables in nested loops).
>>>>>>>>>>>>
>>>>>>>>>>>> If we monitor the execution dynamically, we can likewise
>>>>>>>>>>>> identify
>>>>>>>>>>>> "dynamic basic blocks" sequences of unconditionally executed
>>>>>>>>>>>> instructions with no branches, and we can detect infinite
>>>>>>>>>>>> loops.
>>>>>>>>>>>> (Possibly ones that contain a stack push, if the jump is
>>>>>>>>>>>> actually
>>>>>>>>>>>> a subroutine call.)
>>>>>>>>>>>>
>>>>>>>>>>>> If we simply identify the situation, but don't interfere in
>>>>>>>>>>>> it, then the
>>>>>>>>>>>> situation persists: there is runaway recursion.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When this same simulator monitors its own simulation it could
>>>>>>>>>>> figure out that the H_Hat() invocation of itself is
>>>>>>>>>>> infinitely recursive.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I'm afraid that's "wrong-headed" thinking, because Simulate
>>>>>>>>>> simply DOES NOT monitor its own simulation, so you can't talk
>>>>>>>>>> about when it does something IT DOESN'T DO. :) The same
>>>>>>>>>> mental confusion underlies your ".. /would/ fail to terminate
>>>>>>>>>> /if/ ABNHBD() didn't abort the emulation", and other
>>>>>>>>>> anthropomorphisms you make for TMs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So in other words you cannot possibly begin to imagine that a
>>>>>>>>> software function could be adapted to add functionality.
>>>>>>>>>
>>>>>>>>>> /We/ can figure out that the above H_Hat is infinitely
>>>>>>>>>> recursive, but /we/ are not Simulate, so H_Hat is not our
>>>>>>>>>> "We_hat", and this says nothing about the Linz proof.
>>>>>>>>>>
>>>>>>>>>> The /Simulate/ as you've described it (pure emulation)
>>>>>>>>>> /cannot/ "figure it out", because it fails to return and so
>>>>>>>>>> doesn't "figure" anything. Again, nothing much to say re HP
>>>>>>>>>> proof.
>>>>>>>>>>
>>>>>>>>>> We could code a /new/ emulator routine Simulate2 (distinct
>>>>>>>>>> from H_Hat and Simulate above) which has monitoring logic, and
>>>>>>>>>> use it to examine a simulation of the H_Hat above calling
>>>>>>>>>> Simulate(H_Hat) (note: NOT calling Simulate2...), and this
>>>>>>>>>> Simulate2 could correctly decide that H_Hat(H_Hat) does not
>>>>>>>>>> terminate.
>>>>>>>>>>
>>>>>>>>>> But H_Hat is not the "hatted" machine for Simulate2, so this
>>>>>>>>>> also is of little interest. Nobody claims that "no decider
>>>>>>>>>> can correctly decide halting for H_Hat", only that H does not
>>>>>>>>>> correctly decide halting for its own H_Hat.
>>>>>>>>>>
>>>>>>>>>> If we "update" H_Hat so that instead of calling Simulate, it
>>>>>>>>>> calls the new Simulate2, then we have a /new/ program H_Hat2,
>>>>>>>>>> and a /new/ calculation to consider. When H_Hat2 examines the
>>>>>>>>>> calculation H_Hat2(H_Hat2), with H_Hat2 calling Simulate2
>>>>>>>>>> etc., then H_Hat2 /*cannot*/ "figure out" that the calculation
>>>>>>>>>> has infinite recursion, BECAUSE IT DOESN'T. It can certainly
>>>>>>>>>> /decide/ that H_Hat2 is infinitely recursive, but that would
>>>>>>>>>> just be Simulate2 deciding incorrectly. All in line with Linz
>>>>>>>>>> proof.
>>>>>>>>>>
>>>>>>>>>> Remember, Simulate2 is not a "pure emulator" like Simulate, so
>>>>>>>>>> the fact that there may be two nested emulated calls to
>>>>>>>>>> Simulate2 with the same argument IS NOT PROOF OF INFINITE
>>>>>>>>>> RECURSION.
>>>>>>>>>
>>>>>>>>> When Simulate2() is identical to Simulate() in every way except
>>>>>>>>> that it also examines the execution trace of its input to
>>>>>>>>> figure out that its input is calling Simulate2() in infinite
>>>>>>>>> recursion then by logical necessity H_Hat() is still infinitely
>>>>>>>>> recursive.
>>>>>>>>
>>>>>>>> ?
>>>>>>>>
>>>>>>>> H_Hat doesn't call Simulate2. Maybe you mean H_Hat2 ?
>>>>>>>>
>>>>>>>> Obviously the /H_Hat/ calculation is "still" infinitely
>>>>>>>> recursive, because that calculation has never changed - by
>>>>>>>> definition it calls Simulate (not Simulate2).
>>>>>>>>
>>>>>>>> Hmm, your phrase "figuring out" isn't a standard CS term - I've
>>>>>>>> guessed it to mean that Simulate2 returns some different rc (not
>>>>>>>> 1) when it detects the nested calls to Simulate2 with the same
>>>>>>>> input data, thus making a different decision to the rc=1 [halts]
>>>>>>>> decision. Maybe you mean something else?
>>>>>>>>
>>>>>>>>
>>>>>>>> Mike.
>>>>>>>>
>>>>>> >
>>>>>>> An x86 emulator could keep track of all of the details of the
>>>>>>> execution trace of any input. If the original Simulate() was
>>>>>>> adapted to have this feature and the names remain the same then
>>>>>>> H_Hat() would invoke this updated version of Simulate() and still
>>>>>>> be infinitely recursive.
>>>>>>
>>>>>> So was my guess right? Does "figuring out" mean that Simulate2
>>>>>> returns some different rc (not 1) when it detects the nested calls
>>>>>> to Simulate2 with the same input data, thus making a different
>>>>>> decision to the rc=1 [halts] decision? All you've done is replace
>>>>>> "figuring out" with "keep track of" which is no better.
>>>>>>
>>>>>>>
>>>>>>> When software engineers add features to existing functions they
>>>>>>> do not change the names.
>>>>>>
>>>>>> What they do is change the versions. But you are not a software
>>>>>> engineer, so maybe you don't know about version numbers.
>>>>>>
>>>>>> Software engineers use version control systems so that if required
>>>>>> they can recreate the software at whatever point in the
>>>>>> development cycle is required, so there will not be confusion over
>>>>>> what code is being used/discussed at any time.
>>>>>>
>>>>>
>>>>> This is the version number of the whole system at that point in
>>>>> time. I worked on defense projects using version control. The
>>>>> function almost always keep their original names and merely acquire
>>>>> additional functionality.
>>>>>
>>>>>> In contrast, /you/ habitually use the same name for different
>>>>>> programs, and different names for the same programs. I suspect
>>>>>> this is because in part your arguments rely on confusing different
>>>>>> programs as being the same thing, in various ways. So it seems to
>>>>>> me that you do this deliberately. This is the exact opposite to
>>>>>> how a software engineer or professional programmer would behave.
>>>>>>
>>>>>
>>>>> There are only three programs that I will be talking about:
>>>>>
>>>>> // P has the machine address of H_Hat()
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>> u32 Input_Halts = Simulate(P, P);
>>>>> if (Input_Halts)
>>>>> HERE: goto HERE;
>>>>> return;
>>>>> }
>>>>>
>>>>> That calls Simulate(P, P) and as the conversation progresses will
>>>>> gradually be adapted step-by-step until it becomes Halts(P, P).
>>>>>
>>>>> There will not be any version numbers for Simulate() because
>>>>> Simulate() is merely a conversational convention used to construct
>>>>> complete understanding of Halts() in small incremental steps.
>>>>>
>>>>>
>>>>>> If it is not deliberate, I suggest you just affix versions to the
>>>>>> end of your programs e.g. "H_Hat2" when they change. That's
>>>>>> easier than full versions, e.g. "H_Hat (V2.1.0.0)" and more
>>>>>> appropriate for newsgroup discussions.
>>>>>>
>>>>>>
>>>>>> Mike.
>>>>
>>>> int Simulate_1(u32 P, u32 I);
>>>> Emulates the x86 code pointed to by machine address P with data at
>>>> machine address I.
>>>>
>>>> int Simulate_2(u32 P, u32 I);
>>>> Same as Simulate_1() except keeps track of the execution trace of
>>>> its input including the data passed to any function invocations.
>>>
>>> What does "keeps track of" mean? Does Simulate_2 "do" anything with
>>> this tracked data, or is it just (in this version at least) ignored?
I provide every single detail of exactly what keeps track of means and
you simply ignore it.
It would have probably been easier if I separated out the "keeps track
of" portion so you could see this separately. I have done that now.
This is every single detail that the simulator / halt decider keeps
track of for the computation shown below.
Columns
(1) Sequence number
(2) Machine address of instruction
(3) Machine address of top of stack
(4) Value of top of stack after instruction executed
(5) Number of bytes of machine code
(6) Machine language bytes
(7) Assembly language text
(01)[00000888][00011194][00000000](01) 55 push ebp
(02)[00000889][00011194][00000000](02) 8bec mov ebp,esp
(03)[0000088b][00011190][00000868](05) 6868080000 push 00000868
(04)[00000890][0001118c][00000868](05) 6868080000 push 00000868
(05)[00000895][00011188][0000089a](05) e8defbffff call 00000478
(06)[00000868][00011178][00011184](01) 55 push ebp
(07)[00000869][00011178][00011184](02) 8bec mov ebp,esp
(08)[0000086b][00011178][00011184](03) 8b4508 mov eax,[ebp+08]
(09)[0000086e][00011174][00000868](01) 50 push eax
(10)[0000086f][00011174][00000868](03) 8b4d08 mov ecx,[ebp+08]
(11)[00000872][00011170][00000868](01) 51 push ecx
(12)[00000873][0001116c][00000878](05) e800fcffff call 00000478
(13)[00000868][0001115c][00011168](01) 55 push ebp
(14)[00000869][0001115c][00011168](02) 8bec mov ebp,esp
(15)[0000086b][0001115c][00011168](03) 8b4508 mov eax,[ebp+08]
(16)[0000086e][00011158][00000868](01) 50 push eax
(17)[0000086f][00011158][00000868](03) 8b4d08 mov ecx,[ebp+08]
(18)[00000872][00011154][00000868](01) 51 push ecx
(19)[00000873][00011150][00000878](05) e800fcffff call 00000478
(20)[00000868][00011140][0001114c](01) 55 push ebp
(21)[00000869][00011140][0001114c](02) 8bec mov ebp,esp
(22)[0000086b][00011140][0001114c](03) 8b4508 mov eax,[ebp+08]
(23)[0000086e][0001113c][00000868](01) 50 push eax
(24)[0000086f][0001113c][00000868](03) 8b4d08 mov ecx,[ebp+08]
(25)[00000872][00011138][00000868](01) 51 push ecx
(26)[00000873][00011134][00000878](05) e800fcffff call 00000478
The Simulator / Halt Decider only needs to keep track of the data shown
in the above table. It decodes the machine language and thus ignores the
assembly language. I show all of the details of how it analyzes this
data below.
Minimal criteria for deciding that H_Hat() calls Simulate() in infinite
recursion.
(1) The execution trace of H_Hat() shows that it calls Simulate() from
the same machine address two times in sequence with the same data.
(2) It is assumed that Simulate() either directly invokes its input (as
shown below) or Simulate() emulates the execution of the x86 machine
language of its input (functionally equivalent to the direct execution
shown below).
Does everyone agree that the above criteria is sufficient to definitely
decide that H_Hat() is infinitely recursive?
#include <stdint.h>
#define u32 uint32_t
int Simulate(u32 P, u32 I)
{
((void(*)(u32))P)(I);
}
void H_Hat(u32 P)
{
Simulate(P, P);
}
int main()
{
Simulate((u32)H_Hat, (u32)H_Hat);
}
_Simulate()
[00000478](01) 55 push ebp
[00000479](02) 8bec mov ebp,esp
[0000047b](03) 8b450c mov eax,[ebp+0c]
[0000047e](01) 50 push eax
[0000047f](03) ff5508 call dword [ebp+08]
[00000482](03) 83c404 add esp,+04
[00000485](01) 5d pop ebp
[00000486](01) c3 ret
_H_Hat()
[00000868](01) 55 push ebp
[00000869](02) 8bec mov ebp,esp
[0000086b](03) 8b4508 mov eax,[ebp+08]
[0000086e](01) 50 push eax
[0000086f](03) 8b4d08 mov ecx,[ebp+08]
[00000872](01) 51 push ecx
[00000873](05) e800fcffff call 00000478
[00000878](03) 83c408 add esp,+08
[0000087b](01) 5d pop ebp
[0000087c](01) c3 ret
_main()
[00000888](01) 55 push ebp
[00000889](02) 8bec mov ebp,esp
[0000088b](05) 6868080000 push 00000868
[00000890](05) 6868080000 push 00000868
[00000895](05) e8defbffff call 00000478
[0000089a](03) 83c408 add esp,+08
[0000089d](02) 33c0 xor eax,eax
[0000089f](01) 5d pop ebp
[000008a0](01) c3 ret
Columns
(1) Sequence number
(2) Machine address of instruction
(3) Machine address of top of stack
(4) Value of top of stack after instruction executed
(5) Number of bytes of machine code
(6) Machine language bytes
(7) Assembly language text
(01)[00000888][00011194][00000000](01) 55 push ebp
(02)[00000889][00011194][00000000](02) 8bec mov ebp,esp
(03)[0000088b][00011190][00000868](05) 6868080000 push 00000868
(04)[00000890][0001118c][00000868](05) 6868080000 push 00000868
(05)[00000895][00011188][0000089a](05) e8defbffff call 00000478
(06)[00000868][00011178][00011184](01) 55 push ebp
(07)[00000869][00011178][00011184](02) 8bec mov ebp,esp
(08)[0000086b][00011178][00011184](03) 8b4508 mov eax,[ebp+08]
(09)[0000086e][00011174][00000868](01) 50 push eax
(10)[0000086f][00011174][00000868](03) 8b4d08 mov ecx,[ebp+08]
(11)[00000872][00011170][00000868](01) 51 push ecx
(12)[00000873][0001116c][00000878](05) e800fcffff call 00000478
Line (09) pushes second parameter to Simulate() machine address 0x878
Line (11) pushes first parameter to Simulate() machine address 0x878
Line (12) Calls Simulate(0x878, 0x878);
(13)[00000868][0001115c][00011168](01) 55 push ebp
(14)[00000869][0001115c][00011168](02) 8bec mov ebp,esp
(15)[0000086b][0001115c][00011168](03) 8b4508 mov eax,[ebp+08]
(16)[0000086e][00011158][00000868](01) 50 push eax
(17)[0000086f][00011158][00000868](03) 8b4d08 mov ecx,[ebp+08]
(18)[00000872][00011154][00000868](01) 51 push ecx
(19)[00000873][00011150][00000878](05) e800fcffff call 00000478
Line (16) pushes second parameter to Simulate() machine address 0x878
Line (18) pushes first parameter to Simulate() machine address 0x878
Line (19) Calls Simulate(0x878, 0x878);
(20)[00000868][00011140][0001114c](01) 55 push ebp
(21)[00000869][00011140][0001114c](02) 8bec mov ebp,esp
(22)[0000086b][00011140][0001114c](03) 8b4508 mov eax,[ebp+08]
(23)[0000086e][0001113c][00000868](01) 50 push eax
(24)[0000086f][0001113c][00000868](03) 8b4d08 mov ecx,[ebp+08]
(25)[00000872][00011138][00000868](01) 51 push ecx
(26)[00000873][00011134][00000878](05) e800fcffff call 00000478
Line (23) pushes second parameter to Simulate() machine address 0x878
Line (25) pushes first parameter to Simulate() machine address 0x878
Line (26) Calls Simulate(0x878, 0x878);
Now we have seen that Simulate() is invoked two times from the same
machine address of H_Hat() with the same data. We also know that
Simulate() either executes or emulates the machine language of its input
and nothing more. This seems to provide a sufficient basis for deciding
that H_Hat() is infinitely recursive, thus non-halting.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-02 12:02 +0000 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <87wnupn4q2.fsf@bsb.me.uk> |
| In reply to | #28224 |
olcott <NoOne@NoWhere.com> writes:
> There are only three programs that I will be talking about:
>
> // P has the machine address of H_Hat()
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Simulate(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> return;
> }
This is not a program. It's a function with hint in a comment as to
what program you really mean. You should either write programs, or stop
talking about them and talk about computations instead. I've
illustrated both approaches below.
> That calls Simulate(P, P) and as the conversation progresses will
> gradually be adapted step-by-step until it becomes Halts(P, P).
This looks like a good strategy, but you make so many errors of detail
that you will be arguing about things that don't matter every step of
the way. It's really tedious waiting to find out what the trick is you
are trying to pull this time around.
What you need, but don't have, is a function H such that this program:
#include <stdint.h>
int H(intptr_t P, intptr_t I)
{
// Unknown code
}
void H_Hat(intptr_t P) { if (H(P, P)) while (1); }
int main(void) { return H((intptr_t)H_Hat, (intptr_t)H_Hat); }
correctly returns 1 or 0 indicating the halting or non-halting of this
program:
#include <stdint.h>
int H(intptr_t P, intptr_t I)
{
// Unknown code exactly as in the previous program
}
void H_Hat(intptr_t P) { if (H(P, P)) while (1); }
int main(void) { H_Hat((intptr_t)H_Hat); }
Alternatively, you can have one program reflecting the two key
computations:
#include <stdint.h>
#include <stdio.h>
int H(intptr_t P, intptr_t I)
{
// Unknown code
}
void H_Hat(intptr_t P) { if (H(P, P)) while (1); }
int main(void) {
printf("%d\n", H((intptr_t)H_Hat, (intptr_t)H_Hat));
H_Hat((intptr_t)H_Hat);
}
This program should either print 1 and terminate, or print 0 and fail to
terminate. To everyone but you, this program will make it cryatal clear
why you can't succeed without trickery.
You have some combination of shared data, nested levels of simulation,
or maybe just your old redefined criterion for "correctly" reporting
halting that makes it look, to you, like you have something interesting.
How long must we wait to see what sort of trickery it is this time?
Most of the time you have wasted since apparently having it all sort out
years ago, has been taking up building the smoke machines and polishing
the mirrors. You now have yards of code and mile of traces in which you
have buried the trick. Your original claim, stripped of the lies about
having actual Turing machines, was simple and impossible. You've lost
that clarity. Deliberately so, I imagine.
> There will not be any version numbers for Simulate() because
> Simulate() is merely a conversational convention used to construct
> complete understanding of Halts() in small incremental steps.
You can find your mistake simply by finding the first of those steps
where you move from something boring to something you'd like to boast
about. That is the step at which you introduce the trick.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 09:29 -0600 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <C7mdnRfu1PFXxKP9nZ2dnUU7-dXNnZ2d@giganews.com> |
| In reply to | #28229 |
On 3/2/2021 6:02 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> There are only three programs that I will be talking about:
>>
>> // P has the machine address of H_Hat()
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Simulate(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
>
> This is not a program. It's a function with hint in a comment as to
> what program you really mean. You should either write programs, or stop
> talking about them and talk about computations instead. I've
> illustrated both approaches below.
>
>> That calls Simulate(P, P) and as the conversation progresses will
>> gradually be adapted step-by-step until it becomes Halts(P, P).
>
> This looks like a good strategy, but you make so many errors of detail
> that you will be arguing about things that don't matter every step of
> the way. It's really tedious waiting to find out what the trick is you
> are trying to pull this time around.
>
> What you need, but don't have, is a function H such that this program:
>
> #include <stdint.h>
>
> int H(intptr_t P, intptr_t I)
> {
> // Unknown code
> }
>
> void H_Hat(intptr_t P) { if (H(P, P)) while (1); }
>
> int main(void) { return H((intptr_t)H_Hat, (intptr_t)H_Hat); }
>
> correctly returns 1 or 0 indicating the halting or non-halting of this
> program:
>
> #include <stdint.h>
>
> int H(intptr_t P, intptr_t I)
> {
> // Unknown code exactly as in the previous program
> }
>
> void H_Hat(intptr_t P) { if (H(P, P)) while (1); }
>
> int main(void) { H_Hat((intptr_t)H_Hat); }
>
> Alternatively, you can have one program reflecting the two key
> computations:
>
> #include <stdint.h>
> #include <stdio.h>
>
> int H(intptr_t P, intptr_t I)
> {
> // Unknown code
> }
>
> void H_Hat(intptr_t P) { if (H(P, P)) while (1); }
>
> int main(void) {
> printf("%d\n", H((intptr_t)H_Hat, (intptr_t)H_Hat));
> H_Hat((intptr_t)H_Hat);
> }
>
> This program should either print 1 and terminate, or print 0 and fail to
> terminate. To everyone but you, this program will make it cryatal clear
> why you can't succeed without trickery.
>
> You have some combination of shared data, nested levels of simulation,
> or maybe just your old redefined criterion for "correctly" reporting
> halting that makes it look, to you, like you have something interesting.
> How long must we wait to see what sort of trickery it is this time?
>
> Most of the time you have wasted since apparently having it all sort out
> years ago, has been taking up building the smoke machines and polishing
> the mirrors. You now have yards of code and mile of traces in which you
> have buried the trick. Your original claim, stripped of the lies about
> having actual Turing machines, was simple and impossible. You've lost
> that clarity. Deliberately so, I imagine.
>
>> There will not be any version numbers for Simulate() because
>> Simulate() is merely a conversational convention used to construct
>> complete understanding of Halts() in small incremental steps.
>
> You can find your mistake simply by finding the first of those steps
> where you move from something boring to something you'd like to boast
> about. That is the step at which you introduce the trick.
>
#include <stdint.h>
#define u8 uint8_t
#define u32 uint32_t
#define u16 uint16_t
u32 Halts(u32 P, u32 I)
{
((void(*)(int))P)(I);
return 1;
}
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt = ", Input_Would_Halt);
}
Because the execution trace shown below shows that H_Hat() invokes
Halts() with the same data two times in sequence we can conclude that
H_Hat() is invoked in infinite recursion entirely based on the execution
trace of H_Hat() and the assumption that Halts() does nothing besides
execute or emulate its input.
When Halts() is augmented so that it can see that H_Hat() invokes it two
times in sequence with the same data then Halts() can determine that
H_Hat() is infinitely recursive.
_Halts()
[000004af](01) 55 push ebp
[000004b0](02) 8bec mov ebp,esp
[000004b2](03) 8b450c mov eax,[ebp+0c]
[000004b5](01) 50 push eax
[000004b6](03) ff5508 call dword [ebp+08]
[000004b9](03) 83c404 add esp,+04
[000004bc](05) b801000000 mov eax,00000001
[000004c1](01) 5d pop ebp
[000004c2](01) c3 ret
_H_Hat()
[0000088f](01) 55 push ebp
[00000890](02) 8bec mov ebp,esp
[00000892](01) 51 push ecx
[00000893](03) 8b4508 mov eax,[ebp+08]
[00000896](01) 50 push eax ; 2nd Param
[00000897](03) 8b4d08 mov ecx,[ebp+08]
[0000089a](01) 51 push ecx ; 1st Param
[0000089b](05) e80ffcffff call 000004af ; Halts(P,P)
[000008a0](03) 83c408 add esp,+08
[000008a3](03) 8945fc mov [ebp-04],eax
[000008a6](04) 837dfc00 cmp dword [ebp-04],+00
[000008aa](02) 7402 jz 000008ae
[000008ac](02) ebfe jmp 000008ac
[000008ae](02) 8be5 mov esp,ebp
[000008b0](01) 5d pop ebp
[000008b1](01) c3 ret
_main()
[000008bf](01) 55 push ebp
[000008c0](02) 8bec mov ebp,esp
[000008c2](01) 51 push ecx
[000008c3](05) 688f080000 push 0000088f
[000008c8](05) 688f080000 push 0000088f
[000008cd](05) e8ddfbffff call 000004af
[000008d2](03) 83c408 add esp,+08
[000008d5](03) 8945fc mov [ebp-04],eax
[000008d8](03) 8b45fc mov eax,[ebp-04]
[000008db](01) 50 push eax
[000008dc](05) 680b030000 push 0000030b
[000008e1](05) e869faffff call 0000034f
[000008e6](03) 83c408 add esp,+08
[000008e9](02) 33c0 xor eax,eax
[000008eb](02) 8be5 mov esp,ebp
[000008ed](01) 5d pop ebp
[000008ee](01) c3 ret
Push instructions have already pushed the value shown in their in the
third column. The two push instructions preceding the call to Simulate()
are its second and first parameters respectively.
Columns
(1) Machine address of instruction
(2) Machine address of top of stack
(3) Value of top of stack after instruction executed
(4) Number of bytes of machine code
(5) Machine language bytes
(6) Assembly language text
...[000008bf][00011208][00000000](01) 55 push ebp
...[000008c0][00011208][00000000](02) 8bec mov ebp,esp
...[000008c2][00011204][00000000](01) 51 push ecx
...[000008c3][00011200][0000088f](05) 688f080000 push 0000088f
...[000008c8][000111fc][0000088f](05) 688f080000 push 0000088f
...[000008cd][000111f8][000008d2](05) e8ddfbffff call 000004af
...[0000088f][000111e8][000111f4](01) 55 push ebp
...[00000890][000111e8][000111f4](02) 8bec mov ebp,esp
...[00000892][000111e4][00000000](01) 51 push ecx
...[00000893][000111e4][00000000](03) 8b4508 mov eax,[ebp+08]
...[00000896][000111e0][0000088f](01) 50 push eax ; 2nd Param
...[00000897][000111e0][0000088f](03) 8b4d08 mov ecx,[ebp+08]
...[0000089a][000111dc][0000088f](01) 51 push ecx ; 1st Param
Call Halts(0000088f, 0000088f);
...[0000089b][000111d8][000008a0](05) e80ffcffff call 000004af
...[0000088f][000111c8][000111d4](01) 55 push ebp
...[00000890][000111c8][000111d4](02) 8bec mov ebp,esp
...[00000892][000111c4][0000088f](01) 51 push ecx
...[00000893][000111c4][0000088f](03) 8b4508 mov eax,[ebp+08]
...[00000896][000111c0][0000088f](01) 50 push eax ; 2nd Param
...[00000897][000111c0][0000088f](03) 8b4d08 mov ecx,[ebp+08]
...[0000089a][000111bc][0000088f](01) 51 push ecx ;1st Param
Call Halts(0000088f, 0000088f);
...[0000089b][000111b8][000008a0](05) e80ffcffff call 000004af
It continues to execute the same portion of H_Hat() sequence above
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-03 00:53 +0000 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <87r1kxrra6.fsf@bsb.me.uk> |
| In reply to | #28232 |
olcott <NoOne@NoWhere.com> writes:
> #include <stdint.h>
> #define u8 uint8_t
> #define u32 uint32_t
> #define u16 uint16_t
Curious. I gave you the correct type to use and you changed it back.
And then you continued to use the wrong cast, despite my correcting it:
> u32 Halts(u32 P, u32 I)
> {
> ((void(*)(int))P)(I);
> return 1;
> }
C is not your string suit.
Anyway, you chose not to rise to the challenge I presented, presumably
because you can't. It would have provided more clarity than you have
managed in the last decade or so.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 19:02 -0600 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <LqOdnfB4A8GcfaP9nZ2dnUU7-SOdnZ2d@giganews.com> |
| In reply to | #28296 |
On 3/2/2021 6:53 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> #include <stdint.h>
>> #define u8 uint8_t
>> #define u32 uint32_t
>> #define u16 uint16_t
>
> Curious. I gave you the correct type to use and you changed it back.
> And then you continued to use the wrong cast, despite my correcting it:
>
>> u32 Halts(u32 P, u32 I)
>> {
>> ((void(*)(int))P)(I);
I just recently verified that it is a correct cast for this function:
void H_Hat(u32 P)
u32 is the standard x86utm "tape" element type.
>> return 1;
>> }
>
> C is not your string suit.
No actually the C++ std::string is my string suit.
> Anyway, you chose not to rise to the challenge I presented, presumably
> because you can't. It would have provided more clarity than you have
> managed in the last decade or so.
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-03 01:26 +0000 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <87lfb5rprg.fsf@bsb.me.uk> |
| In reply to | #28297 |
olcott <NoOne@NoWhere.com> writes:
> On 3/2/2021 6:53 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> #include <stdint.h>
>>> #define u8 uint8_t
>>> #define u32 uint32_t
>>> #define u16 uint16_t
>>
>> Curious. I gave you the correct type to use and you changed it back.
>> And then you continued to use the wrong cast, despite my correcting it:
>>
>>> u32 Halts(u32 P, u32 I)
>>> {
>>> ((void(*)(int))P)(I);
>
> I just recently verified that it is a correct cast for this function:
> void H_Hat(u32 P)
You verification method is flawed.
> u32 is the standard x86utm "tape" element type.
There is no TM here, so there is no UTM here either. Whatever /you/
mean by x86utm, it has no standard. If I could get you to learn one
thing, it would be to learn what a TM is and what a UTM is so that you
could stop abusing these technical terms.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 19:35 -0600 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <nKqdnQQ949p4eqP9nZ2dnUU78IHNnZ2d@giganews.com> |
| In reply to | #28298 |
On 3/2/2021 7:26 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/2/2021 6:53 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> #include <stdint.h>
>>>> #define u8 uint8_t
>>>> #define u32 uint32_t
>>>> #define u16 uint16_t
>>>
>>> Curious. I gave you the correct type to use and you changed it back.
>>> And then you continued to use the wrong cast, despite my correcting it:
>>>
>>>> u32 Halts(u32 P, u32 I)
>>>> {
>>>> ((void(*)(int))P)(I);
>>
>> I just recently verified that it is a correct cast for this function:
>> void H_Hat(u32 P)
>
> You verification method is flawed.
What is the correct syntax?
>> u32 is the standard x86utm "tape" element type.
>
> There is no TM here, so there is no UTM here either. Whatever /you/
It is named x86utm because it is the computational equivalent of a UTM
implemented in the von Neumann architecture specified by the x86 language.
> mean by x86utm, it has no standard. If I could get you to learn one
> thing, it would be to learn what a TM is and what a UTM is so that you
> could stop abusing these technical terms.
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-03 01:52 +0000 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <87a6rlroko.fsf@bsb.me.uk> |
| In reply to | #28299 |
olcott <NoOne@NoWhere.com> writes:
> On 3/2/2021 7:26 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/2/2021 6:53 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> #include <stdint.h>
>>>>> #define u8 uint8_t
>>>>> #define u32 uint32_t
>>>>> #define u16 uint16_t
>>>>
>>>> Curious. I gave you the correct type to use and you changed it back.
>>>> And then you continued to use the wrong cast, despite my correcting it:
>>>>
>>>>> u32 Halts(u32 P, u32 I)
>>>>> {
>>>>> ((void(*)(int))P)(I);
>>>
>>> I just recently verified that it is a correct cast for this function:
>>> void H_Hat(u32 P)
>>
>> You verification method is flawed.
>
> What is the correct syntax?
For the type you have chosen (which limits the C implementations you can
use, as compared to the one I used) the correct cast is (void (*)(u32)).
>>> u32 is the standard x86utm "tape" element type.
>>
>> There is no TM here, so there is no UTM here either. Whatever /you/
>
> It is named x86utm because it is the computational equivalent of a UTM
> implemented in the von Neumann architecture specified by the x86
> language.
The x86 is not Turing complete, and "x86 language" is a term you've made
up, but if my guess at what you mean by it is right, it is not Turing
complete either. And even if either or both were, UTM is the wrong term
for something that is not a TM.
You pretend that you want to publish this work, but all serious work in
this subject is done within some formal model of computation. There are
many you could have chosen, or you could have defined your own (I'm
using a generic you here). Choosing "x86 language" (whatever that
really is) is laughable. Obviously I don't want you to change that
decision.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 20:14 -0600 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <lNqdnftaSr6abKP9nZ2dnUU7-TfNnZ2d@giganews.com> |
| In reply to | #28305 |
On 3/2/2021 7:52 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/2/2021 7:26 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/2/2021 6:53 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> #include <stdint.h>
>>>>>> #define u8 uint8_t
>>>>>> #define u32 uint32_t
>>>>>> #define u16 uint16_t
>>>>>
>>>>> Curious. I gave you the correct type to use and you changed it back.
>>>>> And then you continued to use the wrong cast, despite my correcting it:
>>>>>
>>>>>> u32 Halts(u32 P, u32 I)
>>>>>> {
>>>>>> ((void(*)(int))P)(I);
>>>>
>>>> I just recently verified that it is a correct cast for this function:
>>>> void H_Hat(u32 P)
>>>
>>> You verification method is flawed.
>>
>> What is the correct syntax?
>
> For the type you have chosen (which limits the C implementations you can
> use, as compared to the one I used) the correct cast is (void (*)(u32)).
Oh so I called a u32 an int.
I also need to invoke it in the same instruction: ((void(*)(u32))P)(I);
>>>> u32 is the standard x86utm "tape" element type.
>>>
>>> There is no TM here, so there is no UTM here either. Whatever /you/
>>
>> It is named x86utm because it is the computational equivalent of a UTM
>> implemented in the von Neumann architecture specified by the x86
>> language.
>
> The x86 is not Turing complete, and "x86 language" is a term you've made
> up, but if my guess at what you mean by it is right, it is not Turing
> complete either.
It turns out that the relative addressing of the abstract model of
computation that the x86 language specifies provides for a linked list
of an unlimited number of elements of 2GB blocks.
> And even if either or both were, UTM is the wrong term
> for something that is not a TM.
>
computational equivalent of a UTM
computational equivalent of a UTM
computational equivalent of a UTM
computational equivalent of a UTM
> You pretend that you want to publish this work, but all serious work in
> this subject is done within some formal model of computation.
With the utterly ridiculous difficulty that I am having showing that a
simple C program can decide that the following code does indeed specify
infinite recursion that Halts() can recognize I would almost bet my soul
that 10,000-fold more details of the much lower level abstraction
actual Turing machines is not going to help.
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
> There are
> many you could have chosen, or you could have defined your own (I'm
> using a generic you here). Choosing "x86 language" (whatever that
> really is) is laughable. Obviously I don't want you to change that
> decision.
You are not very good at restricting your language to objectivity are you?
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-02 21:49 -0500 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <4PC%H.4$pZ.3@fx40.iad> |
| In reply to | #28308 |
On 3/2/21 9:14 PM, olcott wrote:
> With the utterly ridiculous difficulty that I am having showing that a
> simple C program can decide that the following code does indeed specify
> infinite recursion that Halts() can recognize I would almost bet my soul
> that 10,000-fold more details of the much lower level abstraction
> actual Turing machines is not going to help.
>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> return;
> }
>
The issue here is that once you DEFINE that Halts is a decider, then it
CAN'T be infinitely recursive. It might be infinitely recursive if Halts
didn't meet its requirements, but that is a sort of worthless statement
for showing that Halts can correctly decide H_Hat.
>> There are
>> many you could have chosen, or you could have defined your own (I'm
>> using a generic you here). Choosing "x86 language" (whatever that
>> really is) is laughable. Obviously I don't want you to change that
>> decision.
>
>
> You are not very good at restricting your language to objectivity are you?
>
>
One thing to note, is that there is a point to this, by NOT working in
the actual domains of Turing Machines, since the proof define H and H^
in terms of operations with Turing Machines, you need to be able to
actually PROVE that your particular 'equivalents' are actually related
to the Turing Machines of the proofs. This is not as easy as just saying
they are, and especially when you let your x86 code do stuff that can't
be easily mapped into a Turing Machine.
But even with all of that lousy-goosy issues, you STILL haven't come
close to your goal. The closest you have come is a program that says if
one time I don't meet my requirements, I can give the answer that not
meeting my requirements create. That is NOT countering the proofs you claim.
You other tack has been to totally ignore the actual definitions used in
the proofs and creating your own that sort of maybe sounds a bit like it
if you don't think hard alternate definition that you can answer, but
that answer isn't usable by anything that actually wants to know the
answer to the real halting problem.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 21:31 -0600 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <_MWdnRs9htmGnqL9nZ2dnUU7-WnNnZ2d@giganews.com> |
| In reply to | #28313 |
On 3/2/2021 8:49 PM, Richard Damon wrote:
> On 3/2/21 9:14 PM, olcott wrote:
>> With the utterly ridiculous difficulty that I am having showing that a
>> simple C program can decide that the following code does indeed specify
>> infinite recursion that Halts() can recognize I would almost bet my soul
>> that 10,000-fold more details of the much lower level abstraction
>> actual Turing machines is not going to help.
>>
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Halts(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
>>
>
> The issue here is that once you DEFINE that Halts is a decider, then it
> CAN'T be infinitely recursive. It might be infinitely recursive if Halts
> didn't meet its requirements, but that is a sort of worthless statement
> for showing that Halts can correctly decide H_Hat.
We have to work on the paradoxical step as the very last step and not
jump ahead. I have shown how Halts() can determine that H_Hat()
specifies infinite recursion.
Halts() can analyze the execution trace of its simulation of H_Hat() and
based on this analysis know that H_Hat() invokes Halts() in infinite
recursion.
>>> There are
>>> many you could have chosen, or you could have defined your own (I'm
>>> using a generic you here). Choosing "x86 language" (whatever that
>>> really is) is laughable. Obviously I don't want you to change that
>>> decision.
>>
>>
>> You are not very good at restricting your language to objectivity are you?
>>
>>
>
> One thing to note, is that there is a point to this, by NOT working in
> the actual domains of Turing Machines, since the proof define H and H^
> in terms of operations with Turing Machines, you need to be able to
> actually PROVE that your particular 'equivalents' are actually related
> to the Turing Machines of the proofs.
No I don't and you know that I don't.
As long as I show the x86utm model of computation the high level
abstraction of how the conventional halting problem counter-examples can
be correctly decided then within the assumption of the Church-Turing
thesis it is proven that this can be applied to actual TMs.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-02 23:12 -0500 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <c1E%H.19554$iY.4193@fx33.iad> |
| In reply to | #28318 |
On 3/2/21 10:31 PM, olcott wrote:
> On 3/2/2021 8:49 PM, Richard Damon wrote:
>> On 3/2/21 9:14 PM, olcott wrote:
>>> With the utterly ridiculous difficulty that I am having showing that a
>>> simple C program can decide that the following code does indeed specify
>>> infinite recursion that Halts() can recognize I would almost bet my soul
>>> that 10,000-fold more details of the much lower level abstraction
>>> actual Turing machines is not going to help.
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Input_Halts = Halts(P, P);
>>> if (Input_Halts)
>>> HERE: goto HERE;
>>> return;
>>> }
>>>
>>
>> The issue here is that once you DEFINE that Halts is a decider, then it
>> CAN'T be infinitely recursive. It might be infinitely recursive if Halts
>> didn't meet its requirements, but that is a sort of worthless statement
>> for showing that Halts can correctly decide H_Hat.
>
> We have to work on the paradoxical step as the very last step and not
> jump ahead. I have shown how Halts() can determine that H_Hat()
> specifies infinite recursion.
>
> Halts() can analyze the execution trace of its simulation of H_Hat() and
> based on this analysis know that H_Hat() invokes Halts() in infinite
> recursion.
>
>>>> There are
>>>> many you could have chosen, or you could have defined your own (I'm
>>>> using a generic you here). Choosing "x86 language" (whatever that
>>>> really is) is laughable. Obviously I don't want you to change that
>>>> decision.
>>>
>>>
>>> You are not very good at restricting your language to objectivity are
>>> you?
>>>
>>>
>>
>> One thing to note, is that there is a point to this, by NOT working in
>> the actual domains of Turing Machines, since the proof define H and H^
>> in terms of operations with Turing Machines, you need to be able to
>> actually PROVE that your particular 'equivalents' are actually related
>> to the Turing Machines of the proofs.
>
> No I don't and you know that I don't.
>
> As long as I show the x86utm model of computation the high level
> abstraction of how the conventional halting problem counter-examples can
> be correctly decided then within the assumption of the Church-Turing
> thesis it is proven that this can be applied to actual TMs.
>
>
The proofs that you are working on are all based on building a Turing
machine by a specific formula from the Halt Decider (that is a Turing
Machine). If you can not show that your function H_Hat is built from
your Halt Decider in PRECISELY that way, your argument means NOTHING.
Let me put it another way, your claim is that by showing that you can
decide something with your Halt Decider that the proof says that Halt
Decider can't decide. If the program you put into your decider wasn't
the program that the proof said it couldn't decide, you haven't shown
anything, that would be as much of a proof as me saying my cat told me
that you were wrong, it isn't the test.
If you are unable to PROVE that the function you are deciding is related
to your decider in the right way, your proof is not a proof.
Note, I have pointed out several areas where your 'proof' shows
variation from what the equivalences should be. Thus, your function
H_Hat appears NOT to be related to your function Halts in the right manner.
Note also, even with all these mistakes, you still haven't even gotten
Halts to give the right answer for H_Hat when judged by the REAL
definition of the Halting Problem.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-02 22:30 -0600 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <oa2dnZum5vlwjaL9nZ2dnUU7-QXNnZ2d@giganews.com> |
| In reply to | #28322 |
On 3/2/2021 10:12 PM, Richard Damon wrote:
> On 3/2/21 10:31 PM, olcott wrote:
>> On 3/2/2021 8:49 PM, Richard Damon wrote:
>>> On 3/2/21 9:14 PM, olcott wrote:
>>>> With the utterly ridiculous difficulty that I am having showing that a
>>>> simple C program can decide that the following code does indeed specify
>>>> infinite recursion that Halts() can recognize I would almost bet my soul
>>>> that 10,000-fold more details of the much lower level abstraction
>>>> actual Turing machines is not going to help.
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Input_Halts = Halts(P, P);
>>>> if (Input_Halts)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>
>>> The issue here is that once you DEFINE that Halts is a decider, then it
>>> CAN'T be infinitely recursive. It might be infinitely recursive if Halts
>>> didn't meet its requirements, but that is a sort of worthless statement
>>> for showing that Halts can correctly decide H_Hat.
>>
>> We have to work on the paradoxical step as the very last step and not
>> jump ahead. I have shown how Halts() can determine that H_Hat()
>> specifies infinite recursion.
>>
>> Halts() can analyze the execution trace of its simulation of H_Hat() and
>> based on this analysis know that H_Hat() invokes Halts() in infinite
>> recursion.
>>
>>>>> There are
>>>>> many you could have chosen, or you could have defined your own (I'm
>>>>> using a generic you here). Choosing "x86 language" (whatever that
>>>>> really is) is laughable. Obviously I don't want you to change that
>>>>> decision.
>>>>
>>>>
>>>> You are not very good at restricting your language to objectivity are
>>>> you?
>>>>
>>>>
>>>
>>> One thing to note, is that there is a point to this, by NOT working in
>>> the actual domains of Turing Machines, since the proof define H and H^
>>> in terms of operations with Turing Machines, you need to be able to
>>> actually PROVE that your particular 'equivalents' are actually related
>>> to the Turing Machines of the proofs.
>>
>> No I don't and you know that I don't.
>>
>> As long as I show the x86utm model of computation the high level
>> abstraction of how the conventional halting problem counter-examples can
>> be correctly decided then within the assumption of the Church-Turing
>> thesis it is proven that this can be applied to actual TMs.
>>
>>
>
> The proofs that you are working on are all based on building a Turing
> machine by a specific formula from the Halt Decider (that is a Turing
> Machine). If you can not show that your function H_Hat is built from
> your Halt Decider in PRECISELY that way, your argument means NOTHING.
>
> Let me put it another way, your claim is that by showing that you can
> decide something with your Halt Decider that the proof says that Halt
> Decider can't decide. If the program you put into your decider wasn't
> the program that the proof said it couldn't decide, you haven't shown
> anything, that would be as much of a proof as me saying my cat told me
> that you were wrong, it isn't the test.
>
> If you are unable to PROVE that the function you are deciding is related
> to your decider in the right way, your proof is not a proof.
I don't see how your statement is not flat out dishonest when I have
proved that my function decider is related to its decider in the
conventional halting problem counter-example [do the opposite of
whatever the halt decider decides] way. (Sipser 1997:165)
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt = ", Input_Would_Halt);
}
Now we construct a new Turing machine D with H as a
subroutine. This new TM calls H to determine what M
does when the input to M is its own description <M>.
Once D has determined this information, it does the
opposite. That is, it rejects if M accepts and accepts
if M does not accept. The following is a description of D.
http://www.liarparadox.org/sipser_165.pdf
Sipser, Michael 1997. Introduction to the Theory of Computation. Boston:
PWS Publishing Company (165-167)
It is like I am saying that I know that 2 + 3 = 5 and you are saying you
can't prove that "3" is an integer, how do I know that "3" is an integer
and not a box of chocolates, what is my proof?
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-03 07:49 -0500 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <xBL%H.3495$rp1.1772@fx12.iad> |
| In reply to | #28324 |
On 3/2/21 11:30 PM, olcott wrote:
> On 3/2/2021 10:12 PM, Richard Damon wrote:
>
>> The proofs that you are working on are all based on building a Turing
>> machine by a specific formula from the Halt Decider (that is a Turing
>> Machine). If you can not show that your function H_Hat is built from
>> your Halt Decider in PRECISELY that way, your argument means NOTHING.
>>
>> Let me put it another way, your claim is that by showing that you can
>> decide something with your Halt Decider that the proof says that Halt
>> Decider can't decide. If the program you put into your decider wasn't
>> the program that the proof said it couldn't decide, you haven't shown
>> anything, that would be as much of a proof as me saying my cat told me
>> that you were wrong, it isn't the test.
>>
>> If you are unable to PROVE that the function you are deciding is related
>> to your decider in the right way, your proof is not a proof.
>
> I don't see how your statement is not flat out dishonest when I have
> proved that my function decider is related to its decider in the
> conventional halting problem counter-example [do the opposite of
> whatever the halt decider decides] way. (Sipser 1997:165)
>
WHERE have you PROVED that your code is an exact Computational Equivlent
of the machines described. You have made a very informal statement that
they are, but that has more holes than a block of swiss cheese that you
just refuse to deal with.
I suspect that the fact that you show almost no knowledge of how (or
why) Turing Machines work the way they do it part of the issue. I will
note that you, dispite commenting that you haven't seen the concept in
any literature, just invented out of whole cloth the idea of a Turing
Machine that modifies itself (and the provided implementation was
sending a command to a computer program to edit the description, Maybe
you could show some competency by explaining how using the basic
definition of a Turing Machine it could update its own code).
Key Problems:
1) H_Hat is not making a copy of itself as needed.
2) Lack of distinction between the Turing Machine itself and the input tape.
3) Halts does NOT run the provided program in a private environment, but
in the environment of the other machine. In particular, this restricts
what programs can be run.
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
> Output("Input_Would_Halt = ", Input_Would_Halt);
> }
>
> Now we construct a new Turing machine D with H as a
> subroutine. This new TM calls H to determine what M
> does when the input to M is its own description <M>.
> Once D has determined this information, it does the
> opposite. That is, it rejects if M accepts and accepts
> if M does not accept. The following is a description of D.
>
> http://www.liarparadox.org/sipser_165.pdf
>
> Sipser, Michael 1997. Introduction to the Theory of Computation. Boston:
> PWS Publishing Company (165-167)
>
> It is like I am saying that I know that 2 + 3 = 5 and you are saying you
> can't prove that "3" is an integer, how do I know that "3" is an integer
> and not a box of chocolates, what is my proof?
>
>
You do know that there IS a proof of this, and is partially built on the
fact that we DEFINE meaning to the symbols 2, 3, and 5, and base that
meaning on primitive numerical operations, and then show that the number
we call 5 can be described as the 3rd number after the 2nd number.
Now, someone COULD say they are redefining 3 to be a box of chocolates,
and giving up all of the mathematics based on that. This is sort of what
happens to you when you try to redefine what 'Halting' means in the
Halting Problem.
I will admit that I am not enough of a specialist in that field to be
able to call up that proof at the moment, but I have seen proofs like
this (and if you don't understand this gritty level of number theory the
proof isn't very understandable).
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-03 11:44 +0000 |
| Subject | Re: Detecting infinite recursion (H_Hat is proved to be decidable) |
| Message-ID | <871rcwsbq3.fsf@bsb.me.uk> |
| In reply to | #28308 |
olcott <NoOne@NoWhere.com> writes:
> On 3/2/2021 7:52 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/2/2021 7:26 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/2/2021 6:53 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> #include <stdint.h>
>>>>>>> #define u8 uint8_t
>>>>>>> #define u32 uint32_t
>>>>>>> #define u16 uint16_t
>>>>>>
>>>>>> Curious. I gave you the correct type to use and you changed it back.
>>>>>> And then you continued to use the wrong cast, despite my correcting it:
>>>>>>
>>>>>>> u32 Halts(u32 P, u32 I)
>>>>>>> {
>>>>>>> ((void(*)(int))P)(I);
>>>>>
>>>>> I just recently verified that it is a correct cast for this function:
>>>>> void H_Hat(u32 P)
>>>>
>>>> You verification method is flawed.
>>>
>>> What is the correct syntax?
>>
>> For the type you have chosen (which limits the C implementations you can
>> use, as compared to the one I used) the correct cast is (void (*)(u32)).
>
> Oh so I called a u32 an int.
And the correct type to use in C is intptr_t or uintptr_t. But you have
decided to tie your code to a more narrowly defined version of "x86
language".
> I also need to invoke it in the same instruction: ((void(*)(u32))P)(I);
>
>>>>> u32 is the standard x86utm "tape" element type.
>>>>
>>>> There is no TM here, so there is no UTM here either. Whatever /you/
>>>
>>> It is named x86utm because it is the computational equivalent of a UTM
>>> implemented in the von Neumann architecture specified by the x86
>>> language.
>>
>> The x86 is not Turing complete, and "x86 language" is a term you've made
>> up, but if my guess at what you mean by it is right, it is not Turing
>> complete either.
>
> It turns out that the relative addressing of the abstract model of
> computation that the x86 language specifies provides for a linked list
> of an unlimited number of elements of 2GB blocks.
No. It turns out you failed to write the code for something even as
simple as an unbounded linked list. That's because it's not possible in
the silly model you have picked.
To be clear, you can invent a model of computation that looks a lot like
an x86 implementation where you can have unbounded addresses, but then
why not work in a simple abstract machine rather than the mess that is
the x86? If you pick the x86, you are stuck with its limitations.
Even so, it doesn't matter -- it's simply anther thing you are wrong
about. What you originally claimed to have is just as impossible in a
non-Turing complete notation as in a complete one. And it is almost
certain that the trick you are trying to pull off now does not rely on
the non-Turing completeness of the model.
But the real advantage of using the x86 is the joy you will bring to
some editor's day if you ever submit a paper on computability that uses
it!
>> And even if either or both were, UTM is the wrong term
>> for something that is not a TM.
>
> computational equivalent of a UTM
> computational equivalent of a UTM
> computational equivalent of a UTM
> computational equivalent of a UTM
(a) No.
(b) X being computationally equivalent to X does not make an X a Y.
You did not call it a universal lambda form because it isn't one. You
did not call it a universal Post system because it isn't one. You did
not call it a universal Mealy machine because it isn't one. And you
should not call it a universal Turing machine because it isn't one.
>> You pretend that you want to publish this work, but all serious work in
>> this subject is done within some formal model of computation.
>
> With the utterly ridiculous difficulty that I am having showing that a
> simple C program can decide that the following code does indeed
> specify infinite recursion that Halts() can recognize I would almost
> bet my soul that 10,000-fold more details of the much lower level
> abstraction actual Turing machines is not going to help.
There are much higher-level models that you could have chosen, but you
don't know them, and you dare not read a book on this topic. You chose
"x86 language" because you've come across it, not because it has any
technical benefits for your task. Anyway, I don't want to rock the
boat. Keep using "x86 language" as your model. Journal editor's need a
laugh as much as the next person.
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> return;
> }
>
>> There are
>> many you could have chosen, or you could have defined your own (I'm
>> using a generic you here). Choosing "x86 language" (whatever that
>> really is) is laughable. Obviously I don't want you to change that
>> decision.
>
> You are not very good at restricting your language to objectivity are
> you?
And objective discussion is not possible because you can't write
mathematics. You can't even provide code. You can't meet my challenge
to write a function H that does what you claimed to have done more than
two years ago. Simply providing the code for such an H would
unequivocally show that you have been right all along, but you keep
ducking a diving, making up excuses for why you won't. Here's the
challenge again, to write an H such that these two programs behave
correctly:
H.c:
#include <stdint.h>
int H(intptr_t P, intptr_t I)
{
// code as yet unseen
}
void H_Hat(intptr_t P) { if (H(P, P)) while (1); }
int main(void) { return H((intptr_t)H_Hat, (intptr_t)H_Hat); }
H^.c:
#include <stdint.h>
int H(intptr_t P, intptr_t I)
{
// code as yet unseen
}
void H_Hat(intptr_t P) { if (H(P, P)) while (1); }
int main(void) { H_Hat((intptr_t)H_Hat); }
Writing that H (and you claimed to have such an H two years ago, though
you misled everyone at the time by calling it an "actual Turing
machine") would stop your critics dead (unless you were cheating of
course -- but then there would still be clear code to talk objectively
about).
I expect you will dodge this challenge yet again.
--
Ben.
[toc] | [prev] | [next] | [standalone]
Page 4 of 37 — ← Prev page 1 2 3 [4] 5 6 … 37 Next page →
Back to top | Article view | comp.theory
csiph-web