Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.theory > #28134 > unrolled thread

Detecting infinite recursion

Started byolcott <NoOne@NoWhere.com>
First post2021-02-26 13:53 -0600
Last post2021-03-09 18:31 -0800
Articles 20 on this page of 736 — 18 participants

Back to article view | Back to comp.theory


Contents

  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 6 of 37 — ← Prev page 1 … 4 5 [6] 7 8 … 37  Next page →


#28213

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-01 18:08 -0500
Message-ID<Ote%H.181460$aV5.164707@fx45.iad>
In reply to#28209
On 3/1/21 5:40 PM, olcott wrote:
> On 3/1/2021 4:33 PM, Richard Damon wrote:

>> Since a RASP machine is nothing like an equivalent to a UTM, that isn't
>> much to say. A RASP machine is the computational equivalent to a Turing
>> Machine, not a UTM. 
> 
> As before I am stopping at your first big mistake, the "stored program"
> aspect of a [Random Access Stored Program] machine makes it equivalent
> to a UTM. It is Soft-coded versus hard-coded.
> 

Wrong, a Given RASP machine can only take in programs designed for that
particular instruction set RASP machine. It fails at being 'Universal'

A UTM can take the representation for ANY Turing machine and input and
execute it, that other Turing Machine doesn't need to have a
'compatible' instruction/symbol set, the encoding instructions will just
provide a way to encode any arbitrary size state/symbol list into the
machines representation.

For instance, the 'native' symbol set may be just '0', '1', '2' and the
encoding instructions are to put the symbols into some fixed order and
assign binary numbers to each symbol, and on the tape you put that
binary number followed by a 2. Thus you can put ANY program into that
hardware.

Try that with your RASP machine, see if you can load a program for some
other arbitrary processor into it. You would need to first write and
load the appropriate emulator, and then have it read that program.

To have the equivalent of a UTM for a RASP machine, you would first need
to write a universal emulator, where you first provide an encoding of
the processor (after working out some very generalized description
language that could express ANY cpu description) and then the program
could follow.

FAIL, no existing processor is natively the equivalent of a UTM in this
manner.

[toc] | [prev] | [next] | [standalone]


#28214

Fromolcott <NoOne@NoWhere.com>
Date2021-03-01 17:37 -0600
Message-ID<SbOdnWH12-VW56D9nZ2dnUU7-VednZ2d@giganews.com>
In reply to#28213
On 3/1/2021 5:08 PM, Richard Damon wrote:
> On 3/1/21 5:40 PM, olcott wrote:
>> On 3/1/2021 4:33 PM, Richard Damon wrote:
> 
>>> Since a RASP machine is nothing like an equivalent to a UTM, that isn't
>>> much to say. A RASP machine is the computational equivalent to a Turing
>>> Machine, not a UTM.
>>
>> As before I am stopping at your first big mistake, the "stored program"
>> aspect of a [Random Access Stored Program] machine makes it equivalent
>> to a UTM. It is Soft-coded versus hard-coded.
>>
> 
> Wrong, a Given RASP machine can only take in programs designed for that
> particular instruction set RASP machine. It fails at being 'Universal'
> 

By that same reasoning the fact that a UTM can only execute Turing 
machine descriptions and not x86 program it too is not really universal.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28216

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-01 19:22 -0500
Message-ID<2zf%H.15$hn1.4@fx09.iad>
In reply to#28214
On 3/1/21 6:37 PM, olcott wrote:
> On 3/1/2021 5:08 PM, Richard Damon wrote:
>> On 3/1/21 5:40 PM, olcott wrote:
>>> On 3/1/2021 4:33 PM, Richard Damon wrote:
>>
>>>> Since a RASP machine is nothing like an equivalent to a UTM, that isn't
>>>> much to say. A RASP machine is the computational equivalent to a Turing
>>>> Machine, not a UTM.
>>>
>>> As before I am stopping at your first big mistake, the "stored program"
>>> aspect of a [Random Access Stored Program] machine makes it equivalent
>>> to a UTM. It is Soft-coded versus hard-coded.
>>>
>>
>> Wrong, a Given RASP machine can only take in programs designed for that
>> particular instruction set RASP machine. It fails at being 'Universal'
>>
> 
> By that same reasoning the fact that a UTM can only execute Turing
> machine descriptions and not x86 program it too is not really universal.
> 
> 

Except that x86 progams aren't "Turing Machines" so it should not be
expected for a Universal Turing Machine to run something that isn't a
Turing Machine.

On the other hand, a program designed to run on the Arm Processor on
your phone IS a 'RASP' program, so it would be expected that if you want
ot call something a Universal RASP machine, it should run it.

Heck, your x86 CPU can't even run all programs designed to run on x86
processors, as some will use special features of specific processors,
and then you have all the I/O peripheral requirements. Basically, at the
level of a modern RASP processor, there is enough complexity at the
processor level that the concept of 'Universal' doesn't apply any more.
Will your computer run Windows 3.1? That's an x86 program.

This is part of the distinction between the 'abstract' model of a Turing
Machine, and the practical mess of a real physical processor.

[toc] | [prev] | [next] | [standalone]


#28158

FromRichard Damon <Richard@Damon-Family.org>
Date2021-02-27 21:19 -0500
Message-ID<c5D_H.118777$rQ2.108529@fx14.iad>
In reply to#28150
On 2/27/21 3:40 PM, olcott wrote:
> On 2/27/2021 12:57 PM, Richard Damon wrote:
>> On 2/27/21 10:26 AM, olcott wrote:
>>> On 2/27/2021 9:18 AM, Richard Damon wrote:
>>>> On 2/26/21 4:00 PM, olcott wrote:
>>>>> On 2/26/2021 2:41 PM, Malcolm McLean wrote:
>>>>>> On Friday, 26 February 2021 at 19:53:37 UTC, olcott wrote:
>>>>>>> (1) We know that every software function invoked with the same data
>>>>>>> must
>>>>>>> have the same execution trace.
>>>>>>>
>>>>>> Yes, as long as by "data" we mean everything which the function
>>>>>> reads,
>>>>>> not
>>>>>> only parameters.
>>>>>>>
>>>>>>> (2) When a software function invokes itself this is recursive
>>>>>>> invocation.
>>>>>>>
>>>>>>> (3) When the second recursive invocation of a software function
>>>>>>> calls
>>>>>>> itself with the same data as the prior invocation then it must have
>>>>>>> the
>>>>>>> same execution trace as the prior invocation.
>>>>>>>
>>>>>>> (4) When the second recursive invocation of a software function
>>>>>>> calls
>>>>>>> itself with the same data has no conditional branch instructions
>>>>>>> inbetween these two invocations then this is a case of infinite
>>>>>>> recursion.
>>>>>>>
>>>>>> You don't need 4. If A calls itself with exactly the same data as it
>>>>>> was
>>>>>> originally invoked with, then it must be infitely recursive, even if
>>>>>> there
>>>>>> are conditional branches. It always takes the same branches. The only
>>>>>> question is whether the first invocation makes the recursive call
>>>>>> (depending
>>>>>> how you are using the term "calls").
>>>>>
>>>>> This would seem to be true.
>>>>>
>>>>>>>
>>>>>>> (5) When the recursive invocation is replaced with a call to a
>>>>>>> software
>>>>>>> system that simulates the execution of the calling function with its
>>>>>>> same data, then this is equivalent to a recursive invocation.
>>>>>>>
>>>>>>> // P has address of H_Hat
>>>>>>> void H_Hat(u32 P)
>>>>>>> {
>>>>>>> Simulate(P, P);
>>>>>>> }
>>>>>>>
>>>>>>> Does everyone agree?
>>>>>>>
>>>>>> Yes, you're right. But the caveat I would have is that this system is
>>>>>> wide open
>>>>>> to cheating, because it's hard to verify that Simulate() is not
>>>>>> having
>>>>>> access to
>>>>>> data that varies by invocation level.
>>>>>>
>>>>>
>>>>> If we hypothetically assume that it is a "given" that Simulate() only
>>>>> simulates its input then we should be able to conclude that any
>>>>> invocation meeting the above conditions specifies the equivalent of
>>>>> infinite recursion.
>>>>>
>>>>
>>>> One important point is that these conclusions assume that the function
>>>> described actually exists and that (as stated) the 'software function'
>>>> is actually a true model of a mathematical function (i.e., all inputs
>>>> have been identified).
>>>>
>>>> One key point is that if the function is NOT described as an actual
>>>> computation, but just as a description, then it is possible to make
>>>> contradictory or wrong conclusions if the function is not actually
>>>> finitely computable.
>>>>
>>>
>>> void Simulate(u32 P, u32 I)
>>> {
>>>    ((void(*)(int))P)(I);
>>> }
>>>
>>>
>>> // P has address of H_Hat
>>> void H_Hat(u32 P)
>>> {
>>>    Simulate(P, P);
>>> }
>>>
>>>
>>> Ignoring finite stack space then the above is infinitely recursive
>>> right?
>>>
>>
>> Yes, because you haven't hit any of the limitations I mentioned.
>>
>> Simulate is fully defined and can be seen to not depend on anything not
>> declared as an input.
>>
> 
> When simulate emulates the execution of the x86 machine language (shown
> below) then  the execution trace of H_Hat() showing that Simulate() has
> been invoked a second time in sequence with the same input proves that
> H_Hat() is infinitely recursive. (Assuming that Simulate() only
> simulates it input).

You are now getting on thin ice, since the code to Simulate isn't
provided, its obedience to the requirements isn't verifable.
> 
> 
> // P has the machine address of H_Hat
> void H_Hat2(u32 P)
> {
>   Simulate(P, P);
> }
> 
> _H_Hat()
> [000008a8](01) 55 push ebp
> [000008a9](02) 8bec mov ebp,esp
> [000008ab](03) 8b4508 mov eax,[ebp+08]
> [000008ae](01) 50 push eax
> [000008af](03) 8b4d08 mov ecx,[ebp+08]
> [000008b2](01) 51 push ecx
> [000008b3](05) e8c0fbffff call 00000478
> [000008b8](03) 83c408 add esp,+08
> [000008bb](01) 5d pop ebp
> [000008bc](01) c3 ret
> 
> 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
> 
> Push instructions have 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.
> 
> ...[000008a8][00011220][0001122c](01)  55              push ebp
> ...[000008a9][00011220][0001122c](02)  8bec            mov ebp,esp
> ...[000008ab][00011220][0001122c](03)  8b4508          mov eax,[ebp+08]
> ...[000008ae][0001121c][000008a8](01)  50              push eax
> ...[000008af][0001121c][000008a8](03)  8b4d08          mov ecx,[ebp+08]
> ...[000008b2][00011218][000008a8](01)  51              push ecx
> 
> Call Simulate(000008a8, 000008a8)
> ...[000008b3][00011214][000008b8](05)  e8c0fbffff      call 00000478
> 
> ...[000008a8][00011204][00011210](01)  55              push ebp
> ...[000008a9][00011204][00011210](02)  8bec            mov ebp,esp
> ...[000008ab][00011204][00011210](03)  8b4508          mov eax,[ebp+08]
> ...[000008ae][00011200][000008a8](01)  50              push eax
> ...[000008af][00011200][000008a8](03)  8b4d08          mov ecx,[ebp+08]
> ...[000008b2][000111fc][000008a8](01)  51              push ecx
> 
> Call Simulate(000008a8, 000008a8)
> ...[000008b3][000111f8][000008b8](05)  e8c0fbffff      call 00000478
> 
> Now we can see that H_Hat's call to Simulate() causes H_Hat() to be
> infinitely recursive because its execution trace shows two invocations
> of Simulate() from H_Hat() each with identical input.
>

Note here also that your trace become incomplete here, as we DON't have
a complete cycle, but need to work on assumptions of benign action of
the Simulate function.

Also, thinking ahead of where you are possibly going to go, Simulate is
NOT a functional equivalent for a UTM, as it takes its input
incorrectly, as it doesn't properly distinquish the machine it is
running in from the input tape (and thus it has too much information).
The fact that an instruction is at location X in the code running the
UTM and there is an instruction at location X in the in the code being
simulated should NOT be 'proof' that they are the same point in the
program, because the simulator should be able to simulate an arbitrary
program, when this clearly does not hold.

Note, this then has impact on you concept of detecting infinite
recursion in this way, as the mere repeating of addresses is no long
proof of recursion.

Note also, this is why previously it was suggested that you need to add
a 'process id' column to you traces as location X in one level of
simulation should not be thought of as the same as location X in a
different level, as the simulated program should be able to be different
than the currently running program. The common memory space breaks some
of the properties you are apt to want to assume.

[toc] | [prev] | [next] | [standalone]


#28159

Fromolcott <NoOne@NoWhere.com>
Date2021-02-27 20:36 -0600
Message-ID<-9SdnUj1BZANnKb9nZ2dnUU7-aXNnZ2d@giganews.com>
In reply to#28158
On 2/27/2021 8:19 PM, Richard Damon wrote:
> On 2/27/21 3:40 PM, olcott wrote:
>> On 2/27/2021 12:57 PM, Richard Damon wrote:
>>> On 2/27/21 10:26 AM, olcott wrote:
>>>> On 2/27/2021 9:18 AM, Richard Damon wrote:
>>>>> On 2/26/21 4:00 PM, olcott wrote:
>>>>>> On 2/26/2021 2:41 PM, Malcolm McLean wrote:
>>>>>>> On Friday, 26 February 2021 at 19:53:37 UTC, olcott wrote:
>>>>>>>> (1) We know that every software function invoked with the same data
>>>>>>>> must
>>>>>>>> have the same execution trace.
>>>>>>>>
>>>>>>> Yes, as long as by "data" we mean everything which the function
>>>>>>> reads,
>>>>>>> not
>>>>>>> only parameters.
>>>>>>>>
>>>>>>>> (2) When a software function invokes itself this is recursive
>>>>>>>> invocation.
>>>>>>>>
>>>>>>>> (3) When the second recursive invocation of a software function
>>>>>>>> calls
>>>>>>>> itself with the same data as the prior invocation then it must have
>>>>>>>> the
>>>>>>>> same execution trace as the prior invocation.
>>>>>>>>
>>>>>>>> (4) When the second recursive invocation of a software function
>>>>>>>> calls
>>>>>>>> itself with the same data has no conditional branch instructions
>>>>>>>> inbetween these two invocations then this is a case of infinite
>>>>>>>> recursion.
>>>>>>>>
>>>>>>> You don't need 4. If A calls itself with exactly the same data as it
>>>>>>> was
>>>>>>> originally invoked with, then it must be infitely recursive, even if
>>>>>>> there
>>>>>>> are conditional branches. It always takes the same branches. The only
>>>>>>> question is whether the first invocation makes the recursive call
>>>>>>> (depending
>>>>>>> how you are using the term "calls").
>>>>>>
>>>>>> This would seem to be true.
>>>>>>
>>>>>>>>
>>>>>>>> (5) When the recursive invocation is replaced with a call to a
>>>>>>>> software
>>>>>>>> system that simulates the execution of the calling function with its
>>>>>>>> same data, then this is equivalent to a recursive invocation.
>>>>>>>>
>>>>>>>> // P has address of H_Hat
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>> Simulate(P, P);
>>>>>>>> }
>>>>>>>>
>>>>>>>> Does everyone agree?
>>>>>>>>
>>>>>>> Yes, you're right. But the caveat I would have is that this system is
>>>>>>> wide open
>>>>>>> to cheating, because it's hard to verify that Simulate() is not
>>>>>>> having
>>>>>>> access to
>>>>>>> data that varies by invocation level.
>>>>>>>
>>>>>>
>>>>>> If we hypothetically assume that it is a "given" that Simulate() only
>>>>>> simulates its input then we should be able to conclude that any
>>>>>> invocation meeting the above conditions specifies the equivalent of
>>>>>> infinite recursion.
>>>>>>
>>>>>
>>>>> One important point is that these conclusions assume that the function
>>>>> described actually exists and that (as stated) the 'software function'
>>>>> is actually a true model of a mathematical function (i.e., all inputs
>>>>> have been identified).
>>>>>
>>>>> One key point is that if the function is NOT described as an actual
>>>>> computation, but just as a description, then it is possible to make
>>>>> contradictory or wrong conclusions if the function is not actually
>>>>> finitely computable.
>>>>>
>>>>
>>>> void Simulate(u32 P, u32 I)
>>>> {
>>>>     ((void(*)(int))P)(I);
>>>> }
>>>>
>>>>
>>>> // P has address of H_Hat
>>>> void H_Hat(u32 P)
>>>> {
>>>>     Simulate(P, P);
>>>> }
>>>>
>>>>
>>>> Ignoring finite stack space then the above is infinitely recursive
>>>> right?
>>>>
>>>
>>> Yes, because you haven't hit any of the limitations I mentioned.
>>>
>>> Simulate is fully defined and can be seen to not depend on anything not
>>> declared as an input.
>>>
>>
>> When simulate emulates the execution of the x86 machine language (shown
>> below) then  the execution trace of H_Hat() showing that Simulate() has
>> been invoked a second time in sequence with the same input proves that
>> H_Hat() is infinitely recursive. (Assuming that Simulate() only
>> simulates it input).
> 
> You are now getting on thin ice, since the code to Simulate isn't
> provided, its obedience to the requirements isn't verifable.

I am not asking you to verify the code. The actual code and its full 
execution trace is many hundreds of pages.

I am asking you whether or not code with the properties that I have 
provided can be necessarily determined to be infinitely recursive.

>>
>>
>> // P has the machine address of H_Hat
>> void H_Hat2(u32 P)
>> {
>>    Simulate(P, P);
>> }
>>
>> _H_Hat()
>> [000008a8](01) 55 push ebp
>> [000008a9](02) 8bec mov ebp,esp
>> [000008ab](03) 8b4508 mov eax,[ebp+08]
>> [000008ae](01) 50 push eax
>> [000008af](03) 8b4d08 mov ecx,[ebp+08]
>> [000008b2](01) 51 push ecx
>> [000008b3](05) e8c0fbffff call 00000478
>> [000008b8](03) 83c408 add esp,+08
>> [000008bb](01) 5d pop ebp
>> [000008bc](01) c3 ret
>>
>> 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
>>
>> Push instructions have 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.
>>
>> ...[000008a8][00011220][0001122c](01)  55              push ebp
>> ...[000008a9][00011220][0001122c](02)  8bec            mov ebp,esp
>> ...[000008ab][00011220][0001122c](03)  8b4508          mov eax,[ebp+08]
>> ...[000008ae][0001121c][000008a8](01)  50              push eax
>> ...[000008af][0001121c][000008a8](03)  8b4d08          mov ecx,[ebp+08]
>> ...[000008b2][00011218][000008a8](01)  51              push ecx
>>
>> Call Simulate(000008a8, 000008a8)
>> ...[000008b3][00011214][000008b8](05)  e8c0fbffff      call 00000478
>>
>> ...[000008a8][00011204][00011210](01)  55              push ebp
>> ...[000008a9][00011204][00011210](02)  8bec            mov ebp,esp
>> ...[000008ab][00011204][00011210](03)  8b4508          mov eax,[ebp+08]
>> ...[000008ae][00011200][000008a8](01)  50              push eax
>> ...[000008af][00011200][000008a8](03)  8b4d08          mov ecx,[ebp+08]
>> ...[000008b2][000111fc][000008a8](01)  51              push ecx
>>
>> Call Simulate(000008a8, 000008a8)
>> ...[000008b3][000111f8][000008b8](05)  e8c0fbffff      call 00000478
>>
>> Now we can see that H_Hat's call to Simulate() causes H_Hat() to be
>> infinitely recursive because its execution trace shows two invocations
>> of Simulate() from H_Hat() each with identical input.
>>
> 
> Note here also that your trace become incomplete here, as we DON't have
> a complete cycle, but need to work on assumptions of benign action of
> the Simulate function.
> 

Because the simulator only simulates it is functionally equivalent to 
the original version shown above.

Yes. I don't care about your opinions on any of the other details. I 
only want an objective assessment regarding whether or not the code that 
I specified with the assumptions that I specified can be determined to 
be necessarily infinitely recursive.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28162

FromRichard Damon <Richard@Damon-Family.org>
Date2021-02-27 22:01 -0500
Message-ID<7ID_H.146881$Gd7.77736@fx38.iad>
In reply to#28159
On 2/27/21 9:36 PM, olcott wrote:
> On 2/27/2021 8:19 PM, Richard Damon wrote:
>> On 2/27/21 3:40 PM, olcott wrote:
>>> On 2/27/2021 12:57 PM, Richard Damon wrote:
>>>> On 2/27/21 10:26 AM, olcott wrote:
>>>>> On 2/27/2021 9:18 AM, Richard Damon wrote:
>>>>>> On 2/26/21 4:00 PM, olcott wrote:
>>>>>>> On 2/26/2021 2:41 PM, Malcolm McLean wrote:
>>>>>>>> On Friday, 26 February 2021 at 19:53:37 UTC, olcott wrote:
>>>>>>>>> (1) We know that every software function invoked with the same
>>>>>>>>> data
>>>>>>>>> must
>>>>>>>>> have the same execution trace.
>>>>>>>>>
>>>>>>>> Yes, as long as by "data" we mean everything which the function
>>>>>>>> reads,
>>>>>>>> not
>>>>>>>> only parameters.
>>>>>>>>>
>>>>>>>>> (2) When a software function invokes itself this is recursive
>>>>>>>>> invocation.
>>>>>>>>>
>>>>>>>>> (3) When the second recursive invocation of a software function
>>>>>>>>> calls
>>>>>>>>> itself with the same data as the prior invocation then it must
>>>>>>>>> have
>>>>>>>>> the
>>>>>>>>> same execution trace as the prior invocation.
>>>>>>>>>
>>>>>>>>> (4) When the second recursive invocation of a software function
>>>>>>>>> calls
>>>>>>>>> itself with the same data has no conditional branch instructions
>>>>>>>>> inbetween these two invocations then this is a case of infinite
>>>>>>>>> recursion.
>>>>>>>>>
>>>>>>>> You don't need 4. If A calls itself with exactly the same data
>>>>>>>> as it
>>>>>>>> was
>>>>>>>> originally invoked with, then it must be infitely recursive,
>>>>>>>> even if
>>>>>>>> there
>>>>>>>> are conditional branches. It always takes the same branches. The
>>>>>>>> only
>>>>>>>> question is whether the first invocation makes the recursive call
>>>>>>>> (depending
>>>>>>>> how you are using the term "calls").
>>>>>>>
>>>>>>> This would seem to be true.
>>>>>>>
>>>>>>>>>
>>>>>>>>> (5) When the recursive invocation is replaced with a call to a
>>>>>>>>> software
>>>>>>>>> system that simulates the execution of the calling function
>>>>>>>>> with its
>>>>>>>>> same data, then this is equivalent to a recursive invocation.
>>>>>>>>>
>>>>>>>>> // P has address of H_Hat
>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>> {
>>>>>>>>> Simulate(P, P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Does everyone agree?
>>>>>>>>>
>>>>>>>> Yes, you're right. But the caveat I would have is that this
>>>>>>>> system is
>>>>>>>> wide open
>>>>>>>> to cheating, because it's hard to verify that Simulate() is not
>>>>>>>> having
>>>>>>>> access to
>>>>>>>> data that varies by invocation level.
>>>>>>>>
>>>>>>>
>>>>>>> If we hypothetically assume that it is a "given" that Simulate()
>>>>>>> only
>>>>>>> simulates its input then we should be able to conclude that any
>>>>>>> invocation meeting the above conditions specifies the equivalent of
>>>>>>> infinite recursion.
>>>>>>>
>>>>>>
>>>>>> One important point is that these conclusions assume that the
>>>>>> function
>>>>>> described actually exists and that (as stated) the 'software
>>>>>> function'
>>>>>> is actually a true model of a mathematical function (i.e., all inputs
>>>>>> have been identified).
>>>>>>
>>>>>> One key point is that if the function is NOT described as an actual
>>>>>> computation, but just as a description, then it is possible to make
>>>>>> contradictory or wrong conclusions if the function is not actually
>>>>>> finitely computable.
>>>>>>
>>>>>
>>>>> void Simulate(u32 P, u32 I)
>>>>> {
>>>>>     ((void(*)(int))P)(I);
>>>>> }
>>>>>
>>>>>
>>>>> // P has address of H_Hat
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>>     Simulate(P, P);
>>>>> }
>>>>>
>>>>>
>>>>> Ignoring finite stack space then the above is infinitely recursive
>>>>> right?
>>>>>
>>>>
>>>> Yes, because you haven't hit any of the limitations I mentioned.
>>>>
>>>> Simulate is fully defined and can be seen to not depend on anything not
>>>> declared as an input.
>>>>
>>>
>>> When simulate emulates the execution of the x86 machine language (shown
>>> below) then  the execution trace of H_Hat() showing that Simulate() has
>>> been invoked a second time in sequence with the same input proves that
>>> H_Hat() is infinitely recursive. (Assuming that Simulate() only
>>> simulates it input).
>>
>> You are now getting on thin ice, since the code to Simulate isn't
>> provided, its obedience to the requirements isn't verifable.
> 
> I am not asking you to verify the code. The actual code and its full
> execution trace is many hundreds of pages.
> 
> I am asking you whether or not code with the properties that I have
> provided can be necessarily determined to be infinitely recursive.

First, a lot of the equivocation is because you have shown yourself in
the past to 'try to pull a fast one' by misusing quotes.

If the actual virtual execution path of the program under the simulation
function is identical to that of the first program, then of course the
answer would be yes. The issue is that, based on past performance, you
are apt to some point in the future break one of those conditions and
wish to claim the answer has to be the same, but it doesn't.


> 
>>>
>>>
>>> // P has the machine address of H_Hat
>>> void H_Hat2(u32 P)
>>> {
>>>    Simulate(P, P);
>>> }
>>>
>>> _H_Hat()
>>> [000008a8](01) 55 push ebp
>>> [000008a9](02) 8bec mov ebp,esp
>>> [000008ab](03) 8b4508 mov eax,[ebp+08]
>>> [000008ae](01) 50 push eax
>>> [000008af](03) 8b4d08 mov ecx,[ebp+08]
>>> [000008b2](01) 51 push ecx
>>> [000008b3](05) e8c0fbffff call 00000478
>>> [000008b8](03) 83c408 add esp,+08
>>> [000008bb](01) 5d pop ebp
>>> [000008bc](01) c3 ret
>>>
>>> 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
>>>
>>> Push instructions have 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.
>>>
>>> ...[000008a8][00011220][0001122c](01)  55              push ebp
>>> ...[000008a9][00011220][0001122c](02)  8bec            mov ebp,esp
>>> ...[000008ab][00011220][0001122c](03)  8b4508          mov eax,[ebp+08]
>>> ...[000008ae][0001121c][000008a8](01)  50              push eax
>>> ...[000008af][0001121c][000008a8](03)  8b4d08          mov ecx,[ebp+08]
>>> ...[000008b2][00011218][000008a8](01)  51              push ecx
>>>
>>> Call Simulate(000008a8, 000008a8)
>>> ...[000008b3][00011214][000008b8](05)  e8c0fbffff      call 00000478
>>>
>>> ...[000008a8][00011204][00011210](01)  55              push ebp
>>> ...[000008a9][00011204][00011210](02)  8bec            mov ebp,esp
>>> ...[000008ab][00011204][00011210](03)  8b4508          mov eax,[ebp+08]
>>> ...[000008ae][00011200][000008a8](01)  50              push eax
>>> ...[000008af][00011200][000008a8](03)  8b4d08          mov ecx,[ebp+08]
>>> ...[000008b2][000111fc][000008a8](01)  51              push ecx
>>>
>>> Call Simulate(000008a8, 000008a8)
>>> ...[000008b3][000111f8][000008b8](05)  e8c0fbffff      call 00000478
>>>
>>> Now we can see that H_Hat's call to Simulate() causes H_Hat() to be
>>> infinitely recursive because its execution trace shows two invocations
>>> of Simulate() from H_Hat() each with identical input.
>>>
>>
>> Note here also that your trace become incomplete here, as we DON't have
>> a complete cycle, but need to work on assumptions of benign action of
>> the Simulate function.
>>
> 
> Because the simulator only simulates it is functionally equivalent to
> the original version shown above.
> 
> Yes. I don't care about your opinions on any of the other details. I
> only want an objective assessment regarding whether or not the code that
> I specified with the assumptions that I specified can be determined to
> be necessarily infinitely recursive.
> 

And as I said above, Yes, as long as your code meets the requriements
stated, and the usage is within those parameters, yes.

Note, the trace by itself is NOT sufficient, it needs to be combined
with the description and restriction of the simulator for it to provide
the 'proof' you are describing.

Note again, as you trimmed the remark, Simulate does NOT qualify as a
UTM equivalent as it ooes not run the simulation in an isolated memory
space, it mixing of the machine it is operationg on with the machine it
is simulating makes it unsuitable for that purpose.

[toc] | [prev] | [next] | [standalone]


#28163

Fromolcott <NoOne@NoWhere.com>
Date2021-02-27 21:30 -0600
Message-ID<IuGdnQFwjfPUk6b9nZ2dnUU7-afNnZ2d@giganews.com>
In reply to#28162
On 2/27/2021 9:01 PM, Richard Damon wrote:
> On 2/27/21 9:36 PM, olcott wrote:
>> On 2/27/2021 8:19 PM, Richard Damon wrote:
>>> On 2/27/21 3:40 PM, olcott wrote:
>>>> On 2/27/2021 12:57 PM, Richard Damon wrote:
>>>>> On 2/27/21 10:26 AM, olcott wrote:
>>>>>> On 2/27/2021 9:18 AM, Richard Damon wrote:
>>>>>>> On 2/26/21 4:00 PM, olcott wrote:
>>>>>>>> On 2/26/2021 2:41 PM, Malcolm McLean wrote:
>>>>>>>>> On Friday, 26 February 2021 at 19:53:37 UTC, olcott wrote:
>>>>>>>>>> (1) We know that every software function invoked with the same
>>>>>>>>>> data
>>>>>>>>>> must
>>>>>>>>>> have the same execution trace.
>>>>>>>>>>
>>>>>>>>> Yes, as long as by "data" we mean everything which the function
>>>>>>>>> reads,
>>>>>>>>> not
>>>>>>>>> only parameters.
>>>>>>>>>>
>>>>>>>>>> (2) When a software function invokes itself this is recursive
>>>>>>>>>> invocation.
>>>>>>>>>>
>>>>>>>>>> (3) When the second recursive invocation of a software function
>>>>>>>>>> calls
>>>>>>>>>> itself with the same data as the prior invocation then it must
>>>>>>>>>> have
>>>>>>>>>> the
>>>>>>>>>> same execution trace as the prior invocation.
>>>>>>>>>>
>>>>>>>>>> (4) When the second recursive invocation of a software function
>>>>>>>>>> calls
>>>>>>>>>> itself with the same data has no conditional branch instructions
>>>>>>>>>> inbetween these two invocations then this is a case of infinite
>>>>>>>>>> recursion.
>>>>>>>>>>
>>>>>>>>> You don't need 4. If A calls itself with exactly the same data
>>>>>>>>> as it
>>>>>>>>> was
>>>>>>>>> originally invoked with, then it must be infitely recursive,
>>>>>>>>> even if
>>>>>>>>> there
>>>>>>>>> are conditional branches. It always takes the same branches. The
>>>>>>>>> only
>>>>>>>>> question is whether the first invocation makes the recursive call
>>>>>>>>> (depending
>>>>>>>>> how you are using the term "calls").
>>>>>>>>
>>>>>>>> This would seem to be true.
>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (5) When the recursive invocation is replaced with a call to a
>>>>>>>>>> software
>>>>>>>>>> system that simulates the execution of the calling function
>>>>>>>>>> with its
>>>>>>>>>> same data, then this is equivalent to a recursive invocation.
>>>>>>>>>>
>>>>>>>>>> // P has address of H_Hat
>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>> {
>>>>>>>>>> Simulate(P, P);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Does everyone agree?
>>>>>>>>>>
>>>>>>>>> Yes, you're right. But the caveat I would have is that this
>>>>>>>>> system is
>>>>>>>>> wide open
>>>>>>>>> to cheating, because it's hard to verify that Simulate() is not
>>>>>>>>> having
>>>>>>>>> access to
>>>>>>>>> data that varies by invocation level.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If we hypothetically assume that it is a "given" that Simulate()
>>>>>>>> only
>>>>>>>> simulates its input then we should be able to conclude that any
>>>>>>>> invocation meeting the above conditions specifies the equivalent of
>>>>>>>> infinite recursion.
>>>>>>>>
>>>>>>>
>>>>>>> One important point is that these conclusions assume that the
>>>>>>> function
>>>>>>> described actually exists and that (as stated) the 'software
>>>>>>> function'
>>>>>>> is actually a true model of a mathematical function (i.e., all inputs
>>>>>>> have been identified).
>>>>>>>
>>>>>>> One key point is that if the function is NOT described as an actual
>>>>>>> computation, but just as a description, then it is possible to make
>>>>>>> contradictory or wrong conclusions if the function is not actually
>>>>>>> finitely computable.
>>>>>>>
>>>>>>
>>>>>> void Simulate(u32 P, u32 I)
>>>>>> {
>>>>>>      ((void(*)(int))P)(I);
>>>>>> }
>>>>>>
>>>>>>
>>>>>> // P has address of H_Hat
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>>      Simulate(P, P);
>>>>>> }
>>>>>>
>>>>>>
>>>>>> Ignoring finite stack space then the above is infinitely recursive
>>>>>> right?
>>>>>>
>>>>>
>>>>> Yes, because you haven't hit any of the limitations I mentioned.
>>>>>
>>>>> Simulate is fully defined and can be seen to not depend on anything not
>>>>> declared as an input.
>>>>>
>>>>
>>>> When simulate emulates the execution of the x86 machine language (shown
>>>> below) then  the execution trace of H_Hat() showing that Simulate() has
>>>> been invoked a second time in sequence with the same input proves that
>>>> H_Hat() is infinitely recursive. (Assuming that Simulate() only
>>>> simulates it input).
>>>
>>> You are now getting on thin ice, since the code to Simulate isn't
>>> provided, its obedience to the requirements isn't verifable.
>>
>> I am not asking you to verify the code. The actual code and its full
>> execution trace is many hundreds of pages.
>>
>> I am asking you whether or not code with the properties that I have
>> provided can be necessarily determined to be infinitely recursive.
> 
> First, a lot of the equivocation is because you have shown yourself in
> the past to 'try to pull a fast one' by misusing quotes.
> 
> If the actual virtual execution path of the program under the simulation
> function is identical to that of the first program, then of course the
> answer would be yes. The issue is that, based on past performance, you
> are apt to some point in the future break one of those conditions and
> wish to claim the answer has to be the same, but it doesn't.

Emulating an x86 machine with an x86 machine is functionally equivalent 
to direct execution yet has many thousands of additional steps.

> 
>>
>>>>
>>>>
>>>> // P has the machine address of H_Hat
>>>> void H_Hat2(u32 P)
>>>> {
>>>>     Simulate(P, P);
>>>> }
>>>>
>>>> _H_Hat()
>>>> [000008a8](01) 55 push ebp
>>>> [000008a9](02) 8bec mov ebp,esp
>>>> [000008ab](03) 8b4508 mov eax,[ebp+08]
>>>> [000008ae](01) 50 push eax
>>>> [000008af](03) 8b4d08 mov ecx,[ebp+08]
>>>> [000008b2](01) 51 push ecx
>>>> [000008b3](05) e8c0fbffff call 00000478
>>>> [000008b8](03) 83c408 add esp,+08
>>>> [000008bb](01) 5d pop ebp
>>>> [000008bc](01) c3 ret
>>>>
>>>> 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
>>>>
>>>> Push instructions have 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.
>>>>
>>>> ...[000008a8][00011220][0001122c](01)  55              push ebp
>>>> ...[000008a9][00011220][0001122c](02)  8bec            mov ebp,esp
>>>> ...[000008ab][00011220][0001122c](03)  8b4508          mov eax,[ebp+08]
>>>> ...[000008ae][0001121c][000008a8](01)  50              push eax
>>>> ...[000008af][0001121c][000008a8](03)  8b4d08          mov ecx,[ebp+08]
>>>> ...[000008b2][00011218][000008a8](01)  51              push ecx
>>>>
>>>> Call Simulate(000008a8, 000008a8)
>>>> ...[000008b3][00011214][000008b8](05)  e8c0fbffff      call 00000478
>>>>
>>>> ...[000008a8][00011204][00011210](01)  55              push ebp
>>>> ...[000008a9][00011204][00011210](02)  8bec            mov ebp,esp
>>>> ...[000008ab][00011204][00011210](03)  8b4508          mov eax,[ebp+08]
>>>> ...[000008ae][00011200][000008a8](01)  50              push eax
>>>> ...[000008af][00011200][000008a8](03)  8b4d08          mov ecx,[ebp+08]
>>>> ...[000008b2][000111fc][000008a8](01)  51              push ecx
>>>>
>>>> Call Simulate(000008a8, 000008a8)
>>>> ...[000008b3][000111f8][000008b8](05)  e8c0fbffff      call 00000478
>>>>
>>>> Now we can see that H_Hat's call to Simulate() causes H_Hat() to be
>>>> infinitely recursive because its execution trace shows two invocations
>>>> of Simulate() from H_Hat() each with identical input.
>>>>
>>>
>>> Note here also that your trace become incomplete here, as we DON't have
>>> a complete cycle, but need to work on assumptions of benign action of
>>> the Simulate function.
>>>
>>
>> Because the simulator only simulates it is functionally equivalent to
>> the original version shown above.
>>
>> Yes. I don't care about your opinions on any of the other details. I
>> only want an objective assessment regarding whether or not the code that
>> I specified with the assumptions that I specified can be determined to
>> be necessarily infinitely recursive.
>>
> 
> And as I said above, Yes, as long as your code meets the requirements
> stated, and the usage is within those parameters, yes.
> 
> Note, the trace by itself is NOT sufficient, it needs to be combined
> with the description and restriction of the simulator for it to provide
> the 'proof' you are describing.

The trace combined with the assumption that the simulator only simulates 
is enough within the context of this assumption. If this is not enough 
for you then your understanding is insufficent.

> Note again, as you trimmed the remark, Simulate does NOT qualify as a
> UTM equivalent as it ooes not run the simulation in an isolated memory
> space, it mixing of the machine it is operationg on with the machine it
> is simulating makes it unsuitable for that purpose.
> 

That is a whole other can of worms that will not be addressed for a very 
long time. Unless I proceed in the smallest possible increments of my 
elaboration people jump to the end based on false assumptions never even 
realizing that they are making any assumptions at all.

If we proceed with a purely objective analysis with zero opinions 
what-so-ever involved then and only then can be get through to the end.

So let's sum up where we are:
(1) The following code is obviously infinitely recursive:

void Simulate(u32 P, u32 I)
{
    ((void(*)(int))P)(I);
}


// P has address of H_Hat
void H_Hat(u32 P)
{
   Simulate(P, P);
}

(2) If the Simulate() function is replaced with an x86 emulator that 
emulates its input then this too is obviously infinitely recursive.




-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28136

FromSiri Cruise <chine.bleu@yahoo.com>
Date2021-02-26 12:48 -0800
Message-ID<chine.bleu-8495E8.12481226022021@reader.eternal-september.org>
In reply to#28134
In article <3LadneKdoK8jzKT9nZ2dnUU78T3NnZ2d@giganews.com>,
 olcott <NoOne@NoWhere.com> wrote:

> Does everyone agree?

P = \a.P(succ(a))
P 0


> (1) We know that every software function invoked with the same data must 
> have the same execution trace.

When does a recursion use the same data?

-- 
:-<> Siri Seal of Disavowal #000-001. Disavowed. Denied. Deleted.    @
'I desire mercy, not sacrifice.'                                    /|\
Discordia: not just a religion but also a parody. This post         / \
I am an Andrea Doria sockpuppet.                  insults Islam.  Mohammed

[toc] | [prev] | [next] | [standalone]


#28138

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2021-02-26 21:37 +0000
Message-ID<tSd_H.261436$Wue5.69200@fx13.ams4>
In reply to#28134
On 26/02/2021 19:53, olcott wrote:
> (1) We know that every software function invoked with the same data must have 
> the same execution trace.
> 
> (2) When a software function invokes itself this is recursive invocation.
> 
> (3) When the second recursive invocation of a software function calls itself 
> with the same data as the prior invocation then it must have the same execution 
> trace as the prior invocation.
> 
> (4) When the second recursive invocation of a software function calls itself 
> with the same data has no conditional branch instructions inbetween these two 
> invocations then this is a case of infinite recursion.
> 
> (5) When the recursive invocation is replaced with a call to a software system 
> that simulates the execution of the calling function with its same data, then 
> this is equivalent to a recursive invocation.
> 
> // P has address of H_Hat
> void H_Hat(u32 P)
> {
>    Simulate(P, P);
> }
> 
> Does everyone agree?

No.

(-1) In general for an algorithm or program to perform useful work its functions 
contain branching logic.

(0) Only pure functions may not modify mutable state.

...

(6) ???

(7) ???

(8) ???

...

(???) ???

...

/Flibble

-- 
😎

[toc] | [prev] | [next] | [standalone]


#28139

FromSiri Cruise <chine.bleu@yahoo.com>
Date2021-02-26 15:26 -0800
Message-ID<chine.bleu-776407.15262726022021@reader.eternal-september.org>
In reply to#28138
In article <tSd_H.261436$Wue5.69200@fx13.ams4>,
 Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:

> (-1) In general for an algorithm or program to perform useful work its 
> functions 
> contain branching logic.
> 
> (0) Only pure functions may not modify mutable state.

goldbach = \n.[
    goldbachsum(n, 2, 2) -> goldbach(n+2);
    true -> halt
]
goldbachsum = \n,r,s. [
    r>=n -> false;
    not prime(r, 2) -> goldbachsum(n, r+1, 2);
    not prime(s, 2) -> goldbachsum(n, r, s+1);
    r+s>n -> goldbachsum(n, r+1, 2);
    r+s<n -> goldbachsum(n, r, s+1);
    r+s=n -> true;
]
prime = \n,r.[
    r*r>n -> true;
    n mod r=0 -> false;
    true -> prime(n, r+1)
]

Prove goldbach(2) halts or never halts and you win a Hero of the 
Mathematics badge.

-- 
:-<> Siri Seal of Disavowal #000-001. Disavowed. Denied. Deleted.    @
'I desire mercy, not sacrifice.'                                    /|\
Discordia: not just a religion but also a parody. This post         / \
I am an Andrea Doria sockpuppet.                  insults Islam.  Mohammed

[toc] | [prev] | [next] | [standalone]


#28144

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-02-26 21:49 -0800
Message-ID<s1cmh5$1ug5$2@gioia.aioe.org>
In reply to#28139
On 2/26/2021 3:26 PM, Siri Cruise wrote:
> In article <tSd_H.261436$Wue5.69200@fx13.ams4>,
>   Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
> 
>> (-1) In general for an algorithm or program to perform useful work its
>> functions
>> contain branching logic.
>>
>> (0) Only pure functions may not modify mutable state.
> 
> goldbach = \n.[
>      goldbachsum(n, 2, 2) -> goldbach(n+2);
>      true -> halt
> ]
> goldbachsum = \n,r,s. [
>      r>=n -> false;
>      not prime(r, 2) -> goldbachsum(n, r+1, 2);
>      not prime(s, 2) -> goldbachsum(n, r, s+1);
>      r+s>n -> goldbachsum(n, r+1, 2);
>      r+s<n -> goldbachsum(n, r, s+1);
>      r+s=n -> true;
> ]
> prime = \n,r.[
>      r*r>n -> true;
>      n mod r=0 -> false;
>      true -> prime(n, r+1)
> ]
> 
> Prove goldbach(2) halts or never halts and you win a Hero of the
> Mathematics badge.
> 



When does this halt?

<pseudo code>

trng_rand() is int the following range 0...1

unsigned int
iterate(unsigned int n)
{
    unsigned int hit = 0;

    for (unsigned int i = 0; i < n; ++i)
    {
       if (trng_rand() < .00001)
       {
           if (++hit > 10000)
           {
               return i;
           }

           else
           {
              hit = 0;
           }
       }

       if (trng_rand() > .0000001)
       {
           i = 0;
       }

    }

    return 0;
}

;^)

[toc] | [prev] | [next] | [standalone]


#28145

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-02-26 21:56 -0800
Message-ID<s1cmtl$1kg$1@gioia.aioe.org>
In reply to#28144
On 2/26/2021 9:49 PM, Chris M. Thomasson wrote:
> On 2/26/2021 3:26 PM, Siri Cruise wrote:
>> In article <tSd_H.261436$Wue5.69200@fx13.ams4>,
>>   Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
>>
>>> (-1) In general for an algorithm or program to perform useful work its
>>> functions
>>> contain branching logic.
>>>
>>> (0) Only pure functions may not modify mutable state.
>>
>> goldbach = \n.[
>>      goldbachsum(n, 2, 2) -> goldbach(n+2);
>>      true -> halt
>> ]
>> goldbachsum = \n,r,s. [
>>      r>=n -> false;
>>      not prime(r, 2) -> goldbachsum(n, r+1, 2);
>>      not prime(s, 2) -> goldbachsum(n, r, s+1);
>>      r+s>n -> goldbachsum(n, r+1, 2);
>>      r+s<n -> goldbachsum(n, r, s+1);
>>      r+s=n -> true;
>> ]
>> prime = \n,r.[
>>      r*r>n -> true;
>>      n mod r=0 -> false;
>>      true -> prime(n, r+1)
>> ]
>>
>> Prove goldbach(2) halts or never halts and you win a Hero of the
>> Mathematics badge.
>>
> 
> 
> 
> When does this halt?
> 
> <pseudo code>
> 
> trng_rand() is int the following range 0...1

in the following range 0...1, not int wrt the C type. Damn typos!

> 
> unsigned int
> iterate(unsigned int n)
> {
>     unsigned int hit = 0;
> 
>     for (unsigned int i = 0; i < n; ++i)
>     {
>        if (trng_rand() < .00001)
>        {
>            if (++hit > 10000)
>            {
>                return i;
>            }
> 
>            else
>            {
>               hit = 0;
>            }
>        }
> 
>        if (trng_rand() > .0000001)
>        {
>            i = 0;
>        }
> 
>     }
> 
>     return 0;
> }
> 
> ;^)

[toc] | [prev] | [next] | [standalone]


#28140

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-02-27 01:58 +0000
Message-ID<20210226175333.826@kylheku.com>
In reply to#28134
On 2021-02-26, olcott <NoOne@NoWhere.com> wrote:
> (1) We know that every software function invoked with the same data must 
> have the same execution trace.
>
> (2) When a software function invokes itself this is recursive invocation.
>
> (3) When the second recursive invocation of a software function calls 
> itself with the same data as the prior invocation then it must have the 
> same execution trace as the prior invocation.
>
> (4) When the second recursive invocation of a software function calls 
> itself with the same data has no conditional branch instructions 
> inbetween these two invocations then this is a case of infinite recursion.
>
> (5) When the recursive invocation is replaced with a call to a software 
> system that simulates the execution of the calling function with its 
> same data, then this is equivalent to a recursive invocation.
>
> // P has address of H_Hat
> void H_Hat(u32 P)
> {
>    Simulate(P, P);
> }
>
> Does everyone agree?

If Simulate(P, P) replaces P(P), and the simulation is a faithful
replica of the processor, then nothing has changed.

You have previosuly written about a scheme in which Simulate
contains provisions for monitoring the execution. An outer Simulate has
instruction stream information from all inner Simulate calls and is able
to impose the rule that the simulation will only go to some fixed number
of levels, like 3. Let's call that N.

Firstly, what that does is change H_Hat: H_Hat is no longer infinitely
recursive, because Simulate detects an internal halting condition and
stops.

Secondly, the different recursion levels of H_Hat are not equivalent
to each other.

The outer-most H_Hat goes to N levels of recursion/simulation nesting.

The next lower nesting, though ostensibly executing the same logic,
only has N-1 remaining levels available to it before it will be
terminated.

The one after that N-2.

A function that terminates after U nestings is not the same function
as a similar one which terminates after V nestings, for U != V.

We must treat each H_Hat invocation at every nesting level i as a
different function H_Hat_i.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygna: Cygwin Native Application Library: http://kylheku.com/cygnal

[toc] | [prev] | [next] | [standalone]


#28141

Fromolcott <NoOne@NoWhere.com>
Date2021-02-26 21:24 -0600
Message-ID<itCdnRDfYP3RJqT9nZ2dnUU7-X3NnZ2d@giganews.com>
In reply to#28140
On 2/26/2021 7:58 PM, Kaz Kylheku wrote:
> On 2021-02-26, olcott <NoOne@NoWhere.com> wrote:
>> (1) We know that every software function invoked with the same data must
>> have the same execution trace.
>>
>> (2) When a software function invokes itself this is recursive invocation.
>>
>> (3) When the second recursive invocation of a software function calls
>> itself with the same data as the prior invocation then it must have the
>> same execution trace as the prior invocation.
>>
>> (4) When the second recursive invocation of a software function calls
>> itself with the same data has no conditional branch instructions
>> inbetween these two invocations then this is a case of infinite recursion.

I am estimating the Malcolm is correct that we don't even need to verify 
that there are no conditional branch instructions.

>>
>> (5) When the recursive invocation is replaced with a call to a software
>> system that simulates the execution of the calling function with its
>> same data, then this is equivalent to a recursive invocation.
>>
>> // P has address of H_Hat
>> void H_Hat(u32 P)
>> {
>>     Simulate(P, P);
>> }
>>
>> Does everyone agree?
> 
> If Simulate(P, P) replaces P(P), and the simulation is a faithful
> replica of the processor, then nothing has changed.
> 

I have to proceed in the smallest possible increments of description 
because when I leave any gaps at all they are filled in by false 
assumptions that become immutably unchanged by any future dialogue.

At this point in the elaboration Simulate() only simulates its input.

 From this we can conclude that any execution trace showing a sequence 
of two invocations of Simulate() from H_Hat() with the exact same input 
proves that H_Hat() is necessarily infinitely recursive.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28142

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2021-02-27 03:32 +0000
Message-ID<m3j_H.109462$gK6d.16400@fx27.ams4>
In reply to#28141
On 27/02/2021 03:24, olcott wrote:
> On 2/26/2021 7:58 PM, Kaz Kylheku wrote:
>> On 2021-02-26, olcott <NoOne@NoWhere.com> wrote:
>>> (1) We know that every software function invoked with the same data must
>>> have the same execution trace.
>>>
>>> (2) When a software function invokes itself this is recursive invocation.
>>>
>>> (3) When the second recursive invocation of a software function calls
>>> itself with the same data as the prior invocation then it must have the
>>> same execution trace as the prior invocation.
>>>
>>> (4) When the second recursive invocation of a software function calls
>>> itself with the same data has no conditional branch instructions
>>> inbetween these two invocations then this is a case of infinite recursion.
> 
> I am estimating the Malcolm is correct that we don't even need to verify that 
> there are no conditional branch instructions.

So you have finally resorted to MAGIC in trying to solve the halting problem?

Algorithms have branching logic and non-pure functions can mutate state the 
value of which can effect which branches are taken.  You CANNOT optimize this 
away in some deluded attempt to solve the halting problem.

/Flibble

-- 
😎

[toc] | [prev] | [next] | [standalone]


#28143

FromJeff Barnett <jbb@notatt.com>
Date2021-02-26 21:32 -0700
Message-ID<s1ci0a$3np$1@dont-email.me>
In reply to#28134
On 2/26/2021 12:53 PM, olcott wrote:
> (1) We know that every software function invoked with the same data must 
> have the same execution trace.
> 
> (2) When a software function invokes itself this is recursive invocation.
> 
> (3) When the second recursive invocation of a software function calls 
> itself with the same data as the prior invocation then it must have the 
> same execution trace as the prior invocation.
> 
> (4) When the second recursive invocation of a software function calls 
> itself with the same data has no conditional branch instructions 
> inbetween these two invocations then this is a case of infinite recursion.
> 
> (5) When the recursive invocation is replaced with a call to a software 
> system that simulates the execution of the calling function with its 
> same data, then this is equivalent to a recursive invocation.
> 
> // P has address of H_Hat
> void H_Hat(u32 P)
> {
>    Simulate(P, P);
> }
> 
> Does everyone agree?

You took off all of this time to come up with this. Remember when you 
were pooping in the Lisp group without a clue of what you were talking 
about or knowledge of any modern Lisp? Disgraceful! Consider a function 
which accesses a variable bound outside its scope - there are many 
variations here and this is why you should have learned some Lisp 
instead of just pooping. Then the above is incorrect. Of course you have 
something different in mind but are making a pig of terminology. Above 
you say "software" function and that is what I'm talking about. If you 
mean "mathematical" function, well do you remember the definition of a 
mathematical function? In this case, you are correct but that has little 
or nothing to do with software. I suggest another hiatus for you but 
make it longer this time. Much longer.
-- 
Jeff Barnett

[toc] | [prev] | [next] | [standalone]


#28226

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-03-01 20:04 -0800
Message-ID<s1kdgu$1smv$3@gioia.aioe.org>
In reply to#28134
On 2/26/2021 11:53 AM, olcott wrote:
> (1) We know that every software function invoked with the same data must 
> have the same execution trace.
> 
> (2) When a software function invokes itself this is recursive invocation.
> 
> (3) When the second recursive invocation of a software function calls 
> itself with the same data as the prior invocation then it must have the 
> same execution trace as the prior invocation.
> 
> (4) When the second recursive invocation of a software function calls 
> itself with the same data has no conditional branch instructions 
> inbetween these two invocations then this is a case of infinite recursion.
> 
> (5) When the recursive invocation is replaced with a call to a software 
> system that simulates the execution of the calling function with its 
> same data, then this is equivalent to a recursive invocation.
> 
> // P has address of H_Hat
> void H_Hat(u32 P)
> {
>    Simulate(P, P);
> }
> 
> Does everyone agree?
> 


Are you just detecting infinite recursion simply because you already 
know the tested function is infinity recursive? Try testing a black box 
function...

[toc] | [prev] | [next] | [standalone]


#28227

Fromolcott <NoOne@NoWhere.com>
Date2021-03-01 22:18 -0600
Message-ID<YNmdnbVp4ZsKIaD9nZ2dnUU7-dnNnZ2d@giganews.com>
In reply to#28226
On 3/1/2021 10:04 PM, Chris M. Thomasson wrote:
> On 2/26/2021 11:53 AM, olcott wrote:
>> (1) We know that every software function invoked with the same data 
>> must have the same execution trace.
>>
>> (2) When a software function invokes itself this is recursive invocation.
>>
>> (3) When the second recursive invocation of a software function calls 
>> itself with the same data as the prior invocation then it must have 
>> the same execution trace as the prior invocation.
>>
>> (4) When the second recursive invocation of a software function calls 
>> itself with the same data has no conditional branch instructions 
>> inbetween these two invocations then this is a case of infinite 
>> recursion.
>>
>> (5) When the recursive invocation is replaced with a call to a 
>> software system that simulates the execution of the calling function 
>> with its same data, then this is equivalent to a recursive invocation.
>>
>> // P has address of H_Hat
>> void H_Hat(u32 P)
>> {
>>    Simulate(P, P);
>> }
>>
>> Does everyone agree?
>>
> 
> 
> Are you just detecting infinite recursion simply because you already 
> know the tested function is infinity recursive? Try testing a black box 
> function...

No, the detailed analysis of the execution trace of H_Hat() proves that 
its invocation of Simulate() is infinitely recursive within the 
assumption that Simulate() invokes an x86 emulator that emulates the 
execution of H_Hat() with H_Hat's own machine address as its input.

_H_Hat()
[000008a8](01) 55 push ebp
[000008a9](02) 8bec mov ebp,esp
[000008ab](03) 8b4508 mov eax,[ebp+08]
[000008ae](01) 50 push eax
[000008af](03) 8b4d08 mov ecx,[ebp+08]
[000008b2](01) 51 push ecx
[000008b3](05) e8c0fbffff call 00000478
[000008b8](03) 83c408 add esp,+08
[000008bb](01) 5d pop ebp
[000008bc](01) c3 ret

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

Push instructions have 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.

...[000008a8][00011220][0001122c](01)  55              push ebp
...[000008a9][00011220][0001122c](02)  8bec            mov ebp,esp
...[000008ab][00011220][0001122c](03)  8b4508          mov eax,[ebp+08]
...[000008ae][0001121c][000008a8](01)  50              push eax
...[000008af][0001121c][000008a8](03)  8b4d08          mov ecx,[ebp+08]
...[000008b2][00011218][000008a8](01)  51              push ecx

Call Simulate(000008a8, 000008a8)
...[000008b3][00011214][000008b8](05)  e8c0fbffff      call 00000478

...[000008a8][00011204][00011210](01)  55              push ebp
...[000008a9][00011204][00011210](02)  8bec            mov ebp,esp
...[000008ab][00011204][00011210](03)  8b4508          mov eax,[ebp+08]
...[000008ae][00011200][000008a8](01)  50              push eax
...[000008af][00011200][000008a8](03)  8b4d08          mov ecx,[ebp+08]
...[000008b2][000111fc][000008a8](01)  51              push ecx

Call Simulate(000008a8, 000008a8)
...[000008b3][000111f8][000008b8](05)  e8c0fbffff      call 00000478

Now we can see that H_Hat's call to Simulate() causes H_Hat() to be 
infinitely recursive because its execution trace shows a sequence of two 
invocations of Simulate() from H_Hat() each with identical input.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28230

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-02 07:03 -0500
Message-ID<2Qp%H.245767$iK4.29136@fx43.iad>
In reply to#28227
On 3/1/21 11:18 PM, olcott wrote:
> On 3/1/2021 10:04 PM, Chris M. Thomasson wrote:
>> On 2/26/2021 11:53 AM, olcott wrote:
>>> (1) We know that every software function invoked with the same data
>>> must have the same execution trace.
>>>
>>> (2) When a software function invokes itself this is recursive
>>> invocation.
>>>
>>> (3) When the second recursive invocation of a software function calls
>>> itself with the same data as the prior invocation then it must have
>>> the same execution trace as the prior invocation.
>>>
>>> (4) When the second recursive invocation of a software function calls
>>> itself with the same data has no conditional branch instructions
>>> inbetween these two invocations then this is a case of infinite
>>> recursion.
>>>
>>> (5) When the recursive invocation is replaced with a call to a
>>> software system that simulates the execution of the calling function
>>> with its same data, then this is equivalent to a recursive invocation.
>>>
>>> // P has address of H_Hat
>>> void H_Hat(u32 P)
>>> {
>>>    Simulate(P, P);
>>> }
>>>
>>> Does everyone agree?
>>>
>>
>>
>> Are you just detecting infinite recursion simply because you already
>> know the tested function is infinity recursive? Try testing a black
>> box function...
> 
> No, the detailed analysis of the execution trace of H_Hat() proves that
> its invocation of Simulate() is infinitely recursive within the
> assumption that Simulate() invokes an x86 emulator that emulates the
> execution of H_Hat() with H_Hat's own machine address as its input.
> 
> _H_Hat()
> [000008a8](01) 55 push ebp
> [000008a9](02) 8bec mov ebp,esp
> [000008ab](03) 8b4508 mov eax,[ebp+08]
> [000008ae](01) 50 push eax
> [000008af](03) 8b4d08 mov ecx,[ebp+08]
> [000008b2](01) 51 push ecx
> [000008b3](05) e8c0fbffff call 00000478
> [000008b8](03) 83c408 add esp,+08
> [000008bb](01) 5d pop ebp
> [000008bc](01) c3 ret
> 
> 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
> 
> Push instructions have 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.
> 
> ...[000008a8][00011220][0001122c](01)  55              push ebp
> ...[000008a9][00011220][0001122c](02)  8bec            mov ebp,esp
> ...[000008ab][00011220][0001122c](03)  8b4508          mov eax,[ebp+08]
> ...[000008ae][0001121c][000008a8](01)  50              push eax
> ...[000008af][0001121c][000008a8](03)  8b4d08          mov ecx,[ebp+08]
> ...[000008b2][00011218][000008a8](01)  51              push ecx
> 
> Call Simulate(000008a8, 000008a8)
> ...[000008b3][00011214][000008b8](05)  e8c0fbffff      call 00000478
> 
> ...[000008a8][00011204][00011210](01)  55              push ebp
> ...[000008a9][00011204][00011210](02)  8bec            mov ebp,esp
> ...[000008ab][00011204][00011210](03)  8b4508          mov eax,[ebp+08]
> ...[000008ae][00011200][000008a8](01)  50              push eax
> ...[000008af][00011200][000008a8](03)  8b4d08          mov ecx,[ebp+08]
> ...[000008b2][000111fc][000008a8](01)  51              push ecx
> 
> Call Simulate(000008a8, 000008a8)
> ...[000008b3][000111f8][000008b8](05)  e8c0fbffff      call 00000478
> 
> Now we can see that H_Hat's call to Simulate() causes H_Hat() to be
> infinitely recursive because its execution trace shows a sequence of two
> invocations of Simulate() from H_Hat() each with identical input.
> 
> 
> 

There is also a long list of other assumptions that you aren't listing,
like the program is not connected to an interrupt service routine that
might fire in the future and manipulate the execution context in a way
to break the cycle.

This is a natural part of most real RASP machines, like the x86 language.

This is one reason that merely looking at a trace of a system can't
totally 'prove' something like definite infinite recursion.

This is also one reason things like the Halting Problem are described
theoretically using Turing Machines, they are simple enough not to have
these sorts of issues.

[toc] | [prev] | [next] | [standalone]


#28233

Fromolcott <NoOne@NoWhere.com>
Date2021-03-02 09:33 -0600
Message-ID<C7mdnRbu1PEkx6P9nZ2dnUU7-dWdnZ2d@giganews.com>
In reply to#28230
On 3/2/2021 6:03 AM, Richard Damon wrote:
> On 3/1/21 11:18 PM, olcott wrote:
>> On 3/1/2021 10:04 PM, Chris M. Thomasson wrote:
>>> On 2/26/2021 11:53 AM, olcott wrote:
>>>> (1) We know that every software function invoked with the same data
>>>> must have the same execution trace.
>>>>
>>>> (2) When a software function invokes itself this is recursive
>>>> invocation.
>>>>
>>>> (3) When the second recursive invocation of a software function calls
>>>> itself with the same data as the prior invocation then it must have
>>>> the same execution trace as the prior invocation.
>>>>
>>>> (4) When the second recursive invocation of a software function calls
>>>> itself with the same data has no conditional branch instructions
>>>> inbetween these two invocations then this is a case of infinite
>>>> recursion.
>>>>
>>>> (5) When the recursive invocation is replaced with a call to a
>>>> software system that simulates the execution of the calling function
>>>> with its same data, then this is equivalent to a recursive invocation.
>>>>
>>>> // P has address of H_Hat
>>>> void H_Hat(u32 P)
>>>> {
>>>>     Simulate(P, P);
>>>> }
>>>>
>>>> Does everyone agree?
>>>>
>>>
>>>
>>> Are you just detecting infinite recursion simply because you already
>>> know the tested function is infinity recursive? Try testing a black
>>> box function...
>>
>> No, the detailed analysis of the execution trace of H_Hat() proves that
>> its invocation of Simulate() is infinitely recursive within the
>> assumption that Simulate() invokes an x86 emulator that emulates the
>> execution of H_Hat() with H_Hat's own machine address as its input.
>>
>> _H_Hat()
>> [000008a8](01) 55 push ebp
>> [000008a9](02) 8bec mov ebp,esp
>> [000008ab](03) 8b4508 mov eax,[ebp+08]
>> [000008ae](01) 50 push eax
>> [000008af](03) 8b4d08 mov ecx,[ebp+08]
>> [000008b2](01) 51 push ecx
>> [000008b3](05) e8c0fbffff call 00000478
>> [000008b8](03) 83c408 add esp,+08
>> [000008bb](01) 5d pop ebp
>> [000008bc](01) c3 ret
>>
>> 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
>>
>> Push instructions have 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.
>>
>> ...[000008a8][00011220][0001122c](01)  55              push ebp
>> ...[000008a9][00011220][0001122c](02)  8bec            mov ebp,esp
>> ...[000008ab][00011220][0001122c](03)  8b4508          mov eax,[ebp+08]
>> ...[000008ae][0001121c][000008a8](01)  50              push eax
>> ...[000008af][0001121c][000008a8](03)  8b4d08          mov ecx,[ebp+08]
>> ...[000008b2][00011218][000008a8](01)  51              push ecx
>>
>> Call Simulate(000008a8, 000008a8)
>> ...[000008b3][00011214][000008b8](05)  e8c0fbffff      call 00000478
>>
>> ...[000008a8][00011204][00011210](01)  55              push ebp
>> ...[000008a9][00011204][00011210](02)  8bec            mov ebp,esp
>> ...[000008ab][00011204][00011210](03)  8b4508          mov eax,[ebp+08]
>> ...[000008ae][00011200][000008a8](01)  50              push eax
>> ...[000008af][00011200][000008a8](03)  8b4d08          mov ecx,[ebp+08]
>> ...[000008b2][000111fc][000008a8](01)  51              push ecx
>>
>> Call Simulate(000008a8, 000008a8)
>> ...[000008b3][000111f8][000008b8](05)  e8c0fbffff      call 00000478
>>
>> Now we can see that H_Hat's call to Simulate() causes H_Hat() to be
>> infinitely recursive because its execution trace shows a sequence of two
>> invocations of Simulate() from H_Hat() each with identical input.
>>
>>
>>
> 
> There is also a long list of other assumptions that you aren't listing,
> like the program is not connected to an interrupt service routine that
> might fire in the future and manipulate the execution context in a way
> to break the cycle.
> 
> This is a natural part of most real RASP machines, like the x86 language.
> 
> This is one reason that merely looking at a trace of a system can't
> totally 'prove' something like definite infinite recursion.
> 
> This is also one reason things like the Halting Problem are described
> theoretically using Turing Machines, they are simple enough not to have
> these sorts of issues.
> 

The x86utm operating system does not have the capability of interrupts.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


Page 6 of 37 — ← Prev page 1 … 4 5 [6] 7 8 … 37  Next page →

Back to top | Article view | comp.theory


csiph-web