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


Groups > comp.theory > #31240 > unrolled thread

Infinite recursion detection criteria (Please correct me if I am

Started byolcott <NoOne@nospicedham.NoWhere.com>
First post2021-04-17 09:15 -0500
Last post2021-04-18 15:47 -0400
Articles 20 on this page of 145 — 12 participants

Back to article view | Back to comp.theory


Contents

  Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@nospicedham.NoWhere.com> - 2021-04-17 09:15 -0500
    Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@nospicedham.NoWhere.com> - 2021-04-17 11:01 -0500
    Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 14:02 -0500
    Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 14:23 -0500
      Re: Infinite recursion detection criteria (Please correct me if I am wrong) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-18 01:57 +0000
        Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 21:03 -0500
          Re: Infinite recursion detection criteria (Please correct me if I am wrong) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-18 02:17 +0000
            Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 21:21 -0500
              Re: Infinite recursion detection criteria (Please correct me if I am wrong) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-17 19:27 -0700
          Re: Infinite recursion detection criteria (Please correct me if I am wrong) Richard Damon <Richard@Damon-Family.org> - 2021-04-17 23:50 -0400
            Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) olcott <NoOne@NoWhere.com> - 2021-04-17 22:59 -0500
              Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 07:52 -0400
                Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) olcott <NoOne@NoWhere.com> - 2021-04-18 10:08 -0500
                  Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 15:42 -0400
                    Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) olcott <NoOne@NoWhere.com> - 2021-04-18 15:29 -0500
                      Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-18 13:57 -0700
                      Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 17:55 -0400
                        Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) olcott <NoOne@NoWhere.com> - 2021-04-18 17:03 -0500
                          Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 18:14 -0400
                            Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 00:35 +0100
                              Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 18:42 -0500
                                Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 01:13 +0100
                                  Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 19:47 -0500
                                    Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 02:25 +0100
                                  Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 20:40 -0500
                                    Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 03:00 +0100
                                      Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 21:11 -0500
                                        Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 23:44 +0100
                                          Re: Infinite recursion detection criteria: X() simulates Y() olcott <polcott2@gmail.com> - 2021-04-19 21:02 -0500
                                            Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 03:53 +0100
                                              Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-19 21:57 -0500
                                                Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 04:21 +0100
                                                  Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-19 22:35 -0500
                                                    Re: Infinite recursion detection criteria: (equivalent definitions) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-04-19 22:09 -0700
                                                      Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 00:13 -0500
                                                        Re: Infinite recursion detection criteria: (equivalent definitions) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-04-20 12:34 -0700
                                                    Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 12:00 +0100
                                                      Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 10:34 -0500
                                                        Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 19:27 +0100
                                                          Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 14:22 -0500
                                                            Re: Infinite recursion detection criteria: (equivalent definitions) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-04-20 13:31 -0700
                                                              Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 15:57 -0500
                                                            Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 23:03 +0100
                                                              Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 17:17 -0500
                                                                Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-21 02:15 +0100
                                                                  Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 21:50 -0500
                                                                    Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-21 04:15 +0100
                                                                      Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 22:20 -0500
                                                                        Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-21 15:05 +0100
                                                                          Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-21 09:35 -0500
                                                                            Re: Infinite recursion detection criteria: (equivalent definitions) Richard Damon <Richard@Damon-Family.org> - 2021-04-21 11:03 -0400
                                                                            Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-21 23:32 +0100
                                                                              Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-21 17:39 -0500
                                                                                Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-22 01:37 +0100
                                                                                  Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-21 19:42 -0500
                                                                                    Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-22 02:46 +0100
                                                                                      Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-21 21:22 -0500
                                                                                        Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-22 13:15 +0100
                                                                                          Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 09:33 -0500
                                                                                            Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 00:41 +0100
                                                                                              Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 18:47 -0500
                                                                                                Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 01:12 +0100
                                                                                                  Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 19:15 -0500
                                                                                                    Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 02:05 +0100
                                                                                                      Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 20:12 -0500
                                                                                                        Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 02:37 +0100
                                                                                                          Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 20:44 -0500
                                                                                                            Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 01:27 +0100
                                                                                                              Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 19:53 -0500
                                                                                                                Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 02:34 +0100
                                                                                                                  Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-23 21:00 -0500
                                                                                                                    Re: Infinite recursion detection criteria: (formalized) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 22:24 -0400
                                                                                                                    Re: Infinite recursion detection criteria: (formalized) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 03:45 +0100
                                                                                                                      Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-23 22:00 -0500
                                                                                                                      Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-23 22:02 -0500
                                                                                                                  Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 23:57 -0500
                                                                                                                    Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 23:42 +0100
                                                                                                                  Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-24 21:16 -0500
                                                                                                                    Re: Infinite recursion detection criteria: (formalized) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-25 14:06 +0100
                                                                                                                      Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-25 09:15 -0500
                                                                                                                        Re: Infinite recursion detection criteria: (formalized) Richard Damon <Richard@Damon-Family.org> - 2021-04-25 12:52 -0400
                                                                                                                          Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-25 13:12 -0500
                                                                                                                            Re: Infinite recursion detection criteria: (formalized) Richard Damon <Richard@Damon-Family.org> - 2021-04-25 19:53 -0400
                                                                                                                        Re: Infinite recursion detection criteria: (formalized) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-26 01:48 +0100
                                                                                                                Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 02:42 +0100
                                                                                                              Re: Infinite recursion detection criteria: (Ben contradicts himself) olcott <NoOne@NoWhere.com> - 2021-04-23 20:20 -0500
                                                                                                                Re: Infinite recursion detection criteria: (Ben contradicts himself) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 03:40 +0100
                                                                                                                  Re: Infinite recursion detection criteria: (Ben contradicts himself) olcott <NoOne@NoWhere.com> - 2021-04-23 22:11 -0500
                                                                                                                    Re: Infinite recursion detection criteria: (Ben contradicts himself) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-25 00:22 +0100
                                                                                              Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 20:24 -0500
                                                                                                Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 02:56 +0100
                                                                                                  Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 21:10 -0500
                                                                                                    Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-22 22:45 -0400
                                                                                                      Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 22:19 -0500
                                                                                                        Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 07:43 -0400
                                                                                                          Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 09:19 -0500
                                                                                                            Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 11:19 -0400
                                                                                                              Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 10:48 -0500
                                                                                                                Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 12:22 -0400
                                                                                                                  Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 11:37 -0500
                                                                                                                    Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 13:42 -0400
                                                                                                    Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-23 04:56 +0000
                                                                                                      Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <polcott2@gmail.com> - 2021-04-23 00:04 -0500
                                                                                                        Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 07:43 -0400
                                                                                                    Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 01:35 +0100
                                                                                                      Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 20:13 -0500
                                                                                                        Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 02:53 +0100
                                                                                                          Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 21:03 -0500
                                                                                                            Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 03:49 +0100
                                                                                                              Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 22:16 -0500
                                                                                                                Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 23:02 +0100
                                                                                                Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-22 22:14 -0400
                                                                                                  Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 21:44 -0500
                                                                    Re: Infinite recursion detection criteria: (equivalent definitions) Richard Damon <Richard@Damon-Family.org> - 2021-04-21 07:59 -0400
                                                                      Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-21 09:11 -0500
                                                                        Re: Infinite recursion detection criteria: (equivalent definitions) Richard Damon <Richard@Damon-Family.org> - 2021-04-21 11:16 -0400
                                    Re: Infinite recursion detection criteria: X() simulates Y() Richard Damon <Richard@Damon-Family.org> - 2021-04-18 22:23 -0400
                                      Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 21:25 -0500
                                        Re: Infinite recursion detection criteria: X() simulates Y() Richard Damon <Richard@Damon-Family.org> - 2021-04-19 07:26 -0400
                                          Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-19 10:16 -0500
                                            Re: Infinite recursion detection criteria: (erroneous conflation) olcott <NoOne@NoWhere.com> - 2021-04-19 10:26 -0500
                                              Re: Infinite recursion detection criteria: (erroneous conflation) Richard Damon <Richard@Damon-Family.org> - 2021-04-19 12:03 -0400
                                              Re: Infinite recursion detection criteria: (erroneous conflation) Jeff Barnett <jbb@notatt.com> - 2021-04-19 14:38 -0600
                                            Re: Infinite recursion detection criteria: X() simulates Y() Richard Damon <Richard@Damon-Family.org> - 2021-04-19 22:32 -0400
                                              Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-19 21:53 -0500
                                                Re: Infinite recursion detection criteria: (equivalent definitions) Richard Damon <Richard@Damon-Family.org> - 2021-04-20 08:03 -0400
    Re: Infinite recursion detection criteria (Please correct me if I am Kaz Kylheku <563-365-8930@nospicedham.kylheku.com> - 2021-04-17 15:01 +0000
      Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 17:30 -0500
        Re: Infinite recursion detection criteria (Please correct me if I am Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-18 01:58 +0000
    Re: Infinite recursion detection criteria (Please correct me if I am R Kym Horsell <kym@kymhorsell.com> - 2021-04-18 00:06 +0000
      Re: Infinite recursion detection criteria (Please correct me if I am Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-18 02:16 +0100
        Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 20:30 -0500
          Re: Infinite recursion detection criteria (Please correct me if I am Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-18 02:33 +0100
            Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 20:42 -0500
              Re: Infinite recursion detection criteria (Please correct me if I am Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-18 21:58 +0100
    Re: Infinite recursion detection criteria (Please correct me if I am Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-18 01:35 +0100
      Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 19:38 -0500
    Re: Infinite recursion detection criteria (Please correct me if I am Richard Damon <Richard@Damon-Family.org> - 2021-04-17 22:46 -0400
      Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 21:54 -0500
        Re: Infinite recursion detection criteria (Please correct me if I am wrong) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 00:00 -0400
          Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 23:02 -0500
          Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 23:08 -0500
            Re: Infinite recursion detection criteria (Please correct me if I am wrong) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 07:55 -0400
              Re: Infinite recursion detection criteria (universal halt decider) olcott <NoOne@NoWhere.com> - 2021-04-18 10:20 -0500
                Re: Infinite recursion detection criteria (universal halt decider) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 15:47 -0400

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


#32149 — Re: Infinite recursion detection criteria: (formalized)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-04-25 12:52 -0400
SubjectRe: Infinite recursion detection criteria: (formalized)
Message-ID<17hhI.41733$9F5.24402@fx43.iad>
In reply to#32142
On 4/25/21 10:15 AM, olcott wrote:
> On 4/25/2021 8:06 AM, Ben Bacarisse wrote:

>> Then you should not use a universal quantifier, or make other universal
>> claims.
>>
> 
> The universal quantifier is correct in that every (Must_be_Stopped(x) ≡
> ¬Halting(x))
> 
> We cannot move on to the next point until after you understand this point.
> 
> 

The key here is that Halting(x) is a WELL defined property, so ITS
definition will impose the requirements on Must_be_Stopped(x).

You seem to want to impose an improper definition of Must_be_stopped(x),
which doesn't match this, so you get the wrong answer.

Not that by the PROPER definition, If when Halts(#1) simulates and
decides on H_Hat(#2) which calls Halts(#3) which simulates and decides
on H_Hat(#4), it is possible for Halts(#3) to decide that H_Hat(#4) to
stop its simulation and return the anser to H_Hat(#2), and then
H_Hat(#2) to stop, then it is NOT true that we have shown
Must_be_Stopped(x) is true, as that definition to apply only applies if
Halts(#1) is the only thing that can stop the infinite execution.

If Must_be_stopped(x) extends to those lower levels, then this statement
is NOT true.

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


#32155 — Re: Infinite recursion detection criteria: (formalized)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-25 13:12 -0500
SubjectRe: Infinite recursion detection criteria: (formalized)
Message-ID<gfmdnQWjdIR5LRj9nZ2dnUU7-dPNnZ2d@giganews.com>
In reply to#32149
On 4/25/2021 11:52 AM, Richard Damon wrote:
> On 4/25/21 10:15 AM, olcott wrote:
>> On 4/25/2021 8:06 AM, Ben Bacarisse wrote:
> 
>>> Then you should not use a universal quantifier, or make other universal
>>> claims.
>>>
>>
>> The universal quantifier is correct in that every (Must_be_Stopped(x) ≡
>> ¬Halting(x))
>>
>> We cannot move on to the next point until after you understand this point.
>>
>>
> 
> The key here is that Halting(x) is a WELL defined property, so ITS
> definition will impose the requirements on Must_be_Stopped(x).

Must_be_Stopped(x) means that x would never halt unless the halt decider 
stops simulating x.

When we assume that these two premises are true:
(1) ∀x ∈ Turing_Machine_Descriptions (Must_be_Stopped(x) ≡ ¬Halting(x))
(2) Must_be_Stopped(H_Hat(H_Hat))

Then by logical necessity we can conclude that the halt decider 
correctly decided not halting on H_Hat.

(1) Is a tautology like saying all black cats are black.
(2) Is proven by its execution trace.

If none of the infinitely recursive invocations specified by (2) are 
ever forced to stop then: H_Hat(H_Hat) never ever stops.


-- 
Copyright 2021 Pete Olcott

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

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


#32170 — Re: Infinite recursion detection criteria: (formalized)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-04-25 19:53 -0400
SubjectRe: Infinite recursion detection criteria: (formalized)
Message-ID<xhnhI.128760$ST2.4998@fx47.iad>
In reply to#32155
On 4/25/21 2:12 PM, olcott wrote:
> On 4/25/2021 11:52 AM, Richard Damon wrote:
>> On 4/25/21 10:15 AM, olcott wrote:
>>> On 4/25/2021 8:06 AM, Ben Bacarisse wrote:
>>
>>>> Then you should not use a universal quantifier, or make other universal
>>>> claims.
>>>>
>>>
>>> The universal quantifier is correct in that every (Must_be_Stopped(x) ≡
>>> ¬Halting(x))
>>>
>>> We cannot move on to the next point until after you understand this
>>> point.
>>>
>>>
>>
>> The key here is that Halting(x) is a WELL defined property, so ITS
>> definition will impose the requirements on Must_be_Stopped(x).
> 
> Must_be_Stopped(x) means that x would never halt unless the halt decider
> stops simulating x.

Do you mean that if the TOP level halt decider did not stop it, it will
by necessity run forever, or do you include a copy of the halt decider
that happens to be inside the compuation being analyized.

If the second, then your statement is NOT true.

THis gets into the LYING wordplay you like to use,

For your statement to be true, Must_be_stopoped be mean that the TOP
LEVEL decider need to terminate the machine, and if it doesn.t (perhaps
needing to change the code of JUST the top level decider, since all
other copies were made BEFORE this edit) the machine will run forever,

For H_Hat, it is demonstrably true that H_Hat(H_Hat) WILL Halt on its
own, so Must_be_Stopped for H_Hat(H_Hat) is false.

> 
> When we assume that these two premises are true:
> (1) ∀x ∈ Turing_Machine_Descriptions (Must_be_Stopped(x) ≡ ¬Halting(x))
> (2) Must_be_Stopped(H_Hat(H_Hat))
> 
> Then by logical necessity we can conclude that the halt decider
> correctly decided not halting on H_Hat.
> 
> (1) Is a tautology like saying all black cats are black.
> (2) Is proven by its execution trace.
> 
> If none of the infinitely recursive invocations specified by (2) are
> ever forced to stop then: H_Hat(H_Hat) never ever stops.
> 
> 

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


#32174 — Re: Infinite recursion detection criteria: (formalized)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-26 01:48 +0100
SubjectRe: Infinite recursion detection criteria: (formalized)
Message-ID<87eeexj2fa.fsf@bsb.me.uk>
In reply to#32142
olcott <NoOne@NoWhere.com> writes:

> On 4/25/2021 8:06 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> I AM ADDING THE PROPER ATTRIBUTION
>>>
>>> On 4/22/2021 9:33 AM, olcott wrote:
>>>> We assume the existence of a certain Turing machine F.
>>>> This machine has several properties.
>>>> (a) The parameters to F are a Turing machine description and a finite
>>>>       string.
>>>> (b) F simulates its input pair one state transition at a time.
>>>> (c) F maintains an execution trace list of all of the details of each
>>>>       state transition of the simulation of its input pair.
>>>> (d) After the simulation of each state transition of its input pair H
>>>>       consults this execution trace.
>>>> (e) F can infallibly detect that an input pair specifies infinite
>>>>       execution as some point in its simulation of its input pair.
>>>> (f) At the point where F infallibly detects the infinite execution of
>>>>       its input pair F decides to stop simulating its input.
>>
>> In what sense is this the proper attribution?  It appears to be a
>> misquote.  The original post had no (f).  Are you referring to
>> Message-ID: <readncmm2oqnFBz9nZ2dnUU7-UXNnZ2d@giganews.com>?
>>
>>> My whole purpose of providing all of the above detailed background was
>>> to set up this single point:
>>>
>>> In all the cases where this criteria is met then the above (e) is met:
>>>
>>> When a TM correctly decides to stop simulating its input because this
>>> input would never otherwise halt this TM has correctly decided not
>>> halting on this input.
>>
>> (e) is not something that can be met.  Do you mean that that awful
>> sentence just means that you can sometime detect an input the denotes a
>> non-halting computation?  If that's what you mean, fine.
>>
>>> ∀x ∈ Turing_Machine_Descriptions (Must_be_Stopped(x) ≡ ¬Halting(x))
>>
>> I do look forward to these little poems.  I wonder what this one means.
>> Is it a definition of Must_be_Stopped?  It looks like one.
>>
>>> If my partial halt decider only correctly decides that a single input
>>> x Must_be_Stopped(x) then this input is necessarily ¬Halting(x)
>>
>> Then you should not use a universal quantifier, or make other universal
>> claims.
>
> The universal quantifier is correct in that every (Must_be_Stopped(x)
> ≡ ¬Halting(x))

What is Must_be_Stopped?  If it is a predicate then you are simply
pointlessly renaming ¬Halting.  Pointless for a mathematician, but if
you want to try to bamboozle people with words, you might need to rename
it first.

If that (a trivial renaming) is all the poem means then this

  "If my partial halt decider only correctly decides that a single input
  x Must_be_Stopped(x) then this input is necessarily ¬Halting(x)"

is just a silly sentence that says the same the same thing twice about
one single string (which is not even specified).

From the point of view of clarity, everything you say using the clumsy
name Must_be_Stopped, would be better stated just once in terms of
Halting and/or ¬Halting.

I made the mistake of trying to find a purpose in your math poem.  I
thought you were stating a property of an algorithm you had.

> We cannot move on to the next point until after you understand this
> point.

We cannot move on until you can state what you mean.  Did you really
just intend to re-name ¬Halting(x) with a name you find more evocative?
If so, it makes your math poem genuinely poetic!

But we know the next step anyway.  You have (or will have) a partial
implementation of the ¬Halting test (whatever you end up calling it).
It is used like this:

  bool Halts(u32 P, u32 I)
  {
    bool Halted  = false;
    bool Aborted = false;
    while (!Halted && !Aborted)
    {
      Halted  = DebugStep(P, I);
      Aborted = Needs_To_Be_Aborted(); // *
    }
    return !Aborted;
  }

This is the Halts sketch for which I posted the confounding
computation:

  void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }

You remember that?  You told me that Halts(Confound_Halts,
Confound_Halts) returns false, and that the input to Halt is a finite
computation, i.e. Halts returns the wrong result as everyone knows.

Even you admit that the wrong result can't avoided:

  "That an otherwise correct halt decider can be broken by encoding it to
  get the wrong answer is trivial"

Your way out of this conundrum is to redefine halting using the "two
computations" trick that you've been trying to wrap up in a fuddle of
words to make it less obvious.

Originally you were happy to be clear.  You explained how to get the
other computation -- the line I've marked * was to be commented out:

  When we comment out the line of Halts() that tests for its need to
  abort then H_Hat() remains in infinite recursion, proving that its
  abort decision was correct.

And right there you boldly admit that the "correct" decision has been
redefined.  The halting computation that /uses/ the test and actually
stops, can be /reported/ as non-halting because a related computation,
that does not use that test, /is/ indeed, non-halting.  I suspect you
are now embarrassed by that burst of clarity.

Curiously, at other times, you also try the "Halts does different things
in different contexts" trick:

  "The same halt decider can have different behavior on the same input"

This different behaviour sometimes includes not returning a result at
all.  I'm not sure if you are still trying to pull that one.

-- 
Ben.

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


#32053 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-24 02:42 +0100
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<87pmykmp98.fsf@bsb.me.uk>
In reply to#32045
olcott <NoOne@NoWhere.com> writes:

> I am not going to bother to read all that yet will say that your
> halting criteria would decide that the following finite string
> specifies a halting comutputation on the basis that its simulator
> would stop simulating it.
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }

This is not a computation.  In your silly C-like model, the computation
is this string plus a call like Infinite_Loop() (or maybe you need a
main function -- you don't do details).

My halting criterion says that this is not a halting computation.

-- 
Ben.

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


#32048 — Re: Infinite recursion detection criteria: (Ben contradicts himself)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-23 20:20 -0500
SubjectRe: Infinite recursion detection criteria: (Ben contradicts himself)
Message-ID<HZudnYpWR5Wm7x79nZ2dnUU7-c_NnZ2d@giganews.com>
In reply to#32042
On 4/23/2021 7:27 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>> On 4/22/2021 8:37 PM, Ben Bacarisse wrote:
> 
>>> Please answer my questions.  You carefully describe an F that looks very
>>> much like the code you've been talking about for months.  Do you believe
>>> that such a TM exists?
>>>
>>> I can't see why you'd got to the bother of being so clear and so detailed
>>> to describe something that you think is impossible.
>>
>> What I described is how Halts() correctly decides halting on H_Hat().
> 
> Backpedalling, incompetence or lying -- I am not sure which yet.  

On 4/22/2021 7:41 PM, Ben Bacarisse wrote:
 > olcott <NoOne@NoWhere.com> writes:>> So do you agree with this 
tautology or not?
 >>
 >> When a halt decider correctly decides to stop simulating its input
 >> because this input would never otherwise halt this halt decider has
 >> correctly decided not halting on this input.
 >
 > For what it's worth, it looks very much like a tautology, but the reader
 > should not have to guess the meaning to know if it is or isn't.
 >

So as always you switch to contradicting your own words.


void H_Hat(u32 P)
{
   u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
}

void Infinite_Loop()
{
   HERE: goto HERE;
}

void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
}

int main() {
   Halts((u32)H_Hat, (u32)H_Hat);
   Halts((u32)Infinite_Recursion, 1);
}

The above are all computations meeting this criteria:

 >> When a halt decider correctly decides to stop simulating its input
 >> because this input would never otherwise halt this halt decider has
 >> correctly decided not halting on this input.





-- 
Copyright 2021 Pete Olcott

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

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


#32062 — Re: Infinite recursion detection criteria: (Ben contradicts himself)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-24 03:40 +0100
SubjectRe: Infinite recursion detection criteria: (Ben contradicts himself)
Message-ID<87eef0mmkn.fsf@bsb.me.uk>
In reply to#32048
olcott <NoOne@NoWhere.com> writes:

> On 4/23/2021 7:27 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>> On 4/22/2021 8:37 PM, Ben Bacarisse wrote:
>>
>>>> Please answer my questions.  You carefully describe an F that looks very
>>>> much like the code you've been talking about for months.  Do you believe
>>>> that such a TM exists?
>>>>
>>>> I can't see why you'd got to the bother of being so clear and so detailed
>>>> to describe something that you think is impossible.
>>>
>>> What I described is how Halts() correctly decides halting on H_Hat().
>>
>> Backpedalling, incompetence or lying -- I am not sure which yet.

... Nothing about what I wrote.

This is yet another reply and you /still/ won't address my questions
about what you said.  Unlike you, I am asking questions so you can
explain what you mean.

Take this as the fifth time of asking.

> On 4/22/2021 7:41 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:>> So do you agree with this 
> tautology or not?
>>>
>>> When a halt decider correctly decides to stop simulating its input
>>> because this input would never otherwise halt this halt decider has
>>> correctly decided not halting on this input.
>>
>> For what it's worth, it looks very much like a tautology, but the reader
>> should not have to guess the meaning to know if it is or isn't.

> So as always you switch to contradicting your own words.

This is a common mistake you make.  It stems from not understanding what
I say whilst refusing to follow-up for clarification.

> void H_Hat(u32 P)
> {
>   u32 Input_Halts = Halts(P, P);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> void Infinite_Recursion(u32 N)
> {
>   Infinite_Recursion(N);
> }
>
> int main() {
>   Halts((u32)H_Hat, (u32)H_Hat);
>   Halts((u32)Infinite_Recursion, 1);
> }
>
> The above are all computations meeting this criteria:

These are not computations -- there is a missing function.

>>> When a halt decider correctly decides to stop simulating its input
>>> because this input would never otherwise halt this halt decider has
>>> correctly decided not halting on this input.

You say they meet this badly-worded criterion.  I can't make my own
determination because you won't show us the code for Halts.

We could get somewhere without seeing the top secret code if you would
answer some questions about it:

(a) What value is Input_Halts set to?

(b) What values are returned (and ignored) but the two function calls in
    main?

If you could at least answer these I would stand a chance of verifying
(or refuting) what you say.

-- 
Ben.

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


#32068 — Re: Infinite recursion detection criteria: (Ben contradicts himself)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-23 22:11 -0500
SubjectRe: Infinite recursion detection criteria: (Ben contradicts himself)
Message-ID<-tadncWvXobJER79nZ2dnUU7-RfNnZ2d@giganews.com>
In reply to#32062
On 4/23/2021 9:40 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/23/2021 7:27 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>> On 4/22/2021 8:37 PM, Ben Bacarisse wrote:
>>>
>>>>> Please answer my questions.  You carefully describe an F that looks very
>>>>> much like the code you've been talking about for months.  Do you believe
>>>>> that such a TM exists?
>>>>>
>>>>> I can't see why you'd got to the bother of being so clear and so detailed
>>>>> to describe something that you think is impossible.
>>>>
>>>> What I described is how Halts() correctly decides halting on H_Hat().
>>>
>>> Backpedalling, incompetence or lying -- I am not sure which yet.
> 
> ... Nothing about what I wrote.
> 
> This is yet another reply and you /still/ won't address my questions
> about what you said.  Unlike you, I am asking questions so you can
> explain what you mean.
> 
> Take this as the fifth time of asking.
> 
>> On 4/22/2021 7:41 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:>> So do you agree with this
>> tautology or not?
>>>>
>>>> When a halt decider correctly decides to stop simulating its input
>>>> because this input would never otherwise halt this halt decider has
>>>> correctly decided not halting on this input.
>>>
>>> For what it's worth, it looks very much like a tautology, but the reader
>>> should not have to guess the meaning to know if it is or isn't.
> 
>> So as always you switch to contradicting your own words.
> 
> This is a common mistake you make.  It stems from not understanding what
> I say whilst refusing to follow-up for clarification.
> 
>> void H_Hat(u32 P)
>> {
>>    u32 Input_Halts = Halts(P, P);
>>    if (Input_Halts)
>>      HERE: goto HERE;
>> }
>>
>> void Infinite_Loop()
>> {
>>    HERE: goto HERE;
>> }
>>
>> void Infinite_Recursion(u32 N)
>> {
>>    Infinite_Recursion(N);
>> }
>>
>> int main() {
>>    Halts((u32)H_Hat, (u32)H_Hat);
>>    Halts((u32)Infinite_Recursion, 1);
>> }
>>
>> The above are all computations meeting this criteria:
> 
> These are not computations -- there is a missing function.
> 
>>>> When a halt decider correctly decides to stop simulating its input
>>>> because this input would never otherwise halt this halt decider has
>>>> correctly decided not halting on this input.
> 
> You say they meet this badly-worded criterion.  I can't make my own
> determination because you won't show us the code for Halts.
> 
> We could get somewhere without seeing the top secret code if you would
> answer some questions about it:
> 
> (a) What value is Input_Halts set to?

You should be able to tell from the code that is has no initial value.
As I have explained many hundreds of times the simulation of H_Hat is 
correctly terminated before ever returning any value to H_Hat().

Why do I have to keep repeating these things to you hundreds of times?

That I have to keep repeating these things many hundreds is very strong 
evidence that you have no interest in any honest dialogue. I do have an 
interest in an honest dialogue. If I am wrong I want to know it.

> 
> (b) What values are returned (and ignored) but [by] the two function calls in
>      main?

0, 0

> 
> If you could at least answer these I would stand a chance of verifying
> (or refuting) what you say.
> 

I only want an honest dialogue.

-- 
Copyright 2021 Pete Olcott

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

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


#32122 — Re: Infinite recursion detection criteria: (Ben contradicts himself)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-25 00:22 +0100
SubjectRe: Infinite recursion detection criteria: (Ben contradicts himself)
Message-ID<871razl134.fsf@bsb.me.uk>
In reply to#32068
olcott <NoOne@NoWhere.com> writes:

> On 4/23/2021 9:40 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/23/2021 7:27 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>> On 4/22/2021 8:37 PM, Ben Bacarisse wrote:
>>>>
>>>>>> Please answer my questions.  You carefully describe an F that looks very
>>>>>> much like the code you've been talking about for months.  Do you believe
>>>>>> that such a TM exists?
>>>>>>
>>>>>> I can't see why you'd got to the bother of being so clear and so detailed
>>>>>> to describe something that you think is impossible.
>>>>>
>>>>> What I described is how Halts() correctly decides halting on H_Hat().
>>>>
>>>> Backpedalling, incompetence or lying -- I am not sure which yet.
>>
>> ... Nothing about what I wrote.
>>
>> This is yet another reply and you /still/ won't address my questions
>> about what you said.  Unlike you, I am asking questions so you can
>> explain what you mean.
>>
>> Take this as the fifth time of asking.
>>
>>> On 4/22/2021 7:41 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:>> So do you agree with this
>>> tautology or not?
>>>>>
>>>>> When a halt decider correctly decides to stop simulating its input
>>>>> because this input would never otherwise halt this halt decider has
>>>>> correctly decided not halting on this input.
>>>>
>>>> For what it's worth, it looks very much like a tautology, but the reader
>>>> should not have to guess the meaning to know if it is or isn't.
>>
>>> So as always you switch to contradicting your own words.
>>
>> This is a common mistake you make.  It stems from not understanding what
>> I say whilst refusing to follow-up for clarification.
>>
>>> void H_Hat(u32 P)
>>> {
>>>    u32 Input_Halts = Halts(P, P);
>>>    if (Input_Halts)
>>>      HERE: goto HERE;
>>> }
>>>
>>> void Infinite_Loop()
>>> {
>>>    HERE: goto HERE;
>>> }
>>>
>>> void Infinite_Recursion(u32 N)
>>> {
>>>    Infinite_Recursion(N);
>>> }
>>>
>>> int main() {
>>>    Halts((u32)H_Hat, (u32)H_Hat);
>>>    Halts((u32)Infinite_Recursion, 1);
>>> }
>>>
>>> The above are all computations meeting this criteria:
>>
>> These are not computations -- there is a missing function.
>>
>>>>> When a halt decider correctly decides to stop simulating its input
>>>>> because this input would never otherwise halt this halt decider has
>>>>> correctly decided not halting on this input.
>>
>> You say they meet this badly-worded criterion.  I can't make my own
>> determination because you won't show us the code for Halts.
>>
>> We could get somewhere without seeing the top secret code if you would
>> answer some questions about it:
>>
>> (a) What value is Input_Halts set to?
>
> You should be able to tell from the code that is has no initial value.

You expect me to confirm what you say about code you are deliberately
hiding?

> As I have explained many hundreds of times the simulation of H_Hat is
> correctly terminated before ever returning any value to H_Hat().

The only time you ever gave enough information about Halts to have any
idea what it does, it always returned a value to the calling function.
The story changes, depending on the problem you currently face.

> Why do I have to keep repeating these things to you hundreds of times?

Because you change what you say to suite the situation.

The most egregious example of this was when Mike Terry asked a couple of
detailed questions about all the obvious tricks as soon as you made the
Big Claim (soon to become the Big Lie) in Dec 2018.  You have reneged on
these answers since, but the exact manner of deception changes depending
on the context asked.

> That I have to keep repeating these things many hundreds is very
> strong evidence that you have no interest in any honest dialogue. I do
> have an interest in an honest dialogue. If I am wrong I want to know
> it.

So the answer today is "Halts does not return a value in the call you
asked about".  Even if you have said this 1000 times, and never said
anything else about it, your should always just re-state as this keeps
the information available to readers who have not been following your
20-year decent into the rabbit hole.

(One of the most helpful crank indicators is the answer "I've told you
many times" rather than the often shorter "yes" or "no" answer.  Honest
academics just answer questions, often again and again, because that's
the only way to keep the discussion clear to current readers.)

>> (b) What values are returned (and ignored) but [by] the two function calls in
>>      main?
>
> 0, 0

So, today at least, all I am permitted to know is that a hidden
simulation (there is no simulation code shown) of H_Hat (a function, not
a function call so not a computation) is halted in some way so as to
avoid return a value to the bit of code you /do/ deign to show?  And
from this, I should pat you on that back and confirm that 0 is the
correct return for Halts in the first call in main?

The other day, things were different.  You gave a sketch of Halts:

  bool Halts(u32 P, u32 I)
  {
    bool Halted  = false;
    bool Aborted = false;
    while (!Halted && !Aborted)
    {
      Halted  = DebugStep(P, I);
      Aborted = Needs_To_Be_Aborted();
    }
    return !Aborted;
  }

This function, you explained, does what a decider should do and always
return to its caller.  On /that/ day always returning was more important
than trying to avoid the wrong return value.  Not so today because today
you are trying to weasel out a different problem than the one you faced
when you posted this sketch.

But this is never the end of it.  As someone once said, your errors are
fractals.  As you look at more detail, more errors emerge.  If I were to
go into the fact that Halts must always return the same value when
called with the same arguments, you will open up new rich seems of
errors about what is a computation, and what is a pure function and
goodness knows what else.

>> If you could at least answer these I would stand a chance of verifying
>> (or refuting) what you say.
>
> I only want an honest dialogue.

Then you need to stop equivocating, and start giving honest answers to
direct questions.

-- 
Ben.

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


#31945 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-22 20:24 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<gf2dnW5C2JZ6vB_9nZ2dnUU7-fPNnZ2d@giganews.com>
In reply to#31929
On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/22/2021 7:15 AM, Ben Bacarisse wrote:
> ...
>>> This sentence...
> 
> ... I've cut all of my text because I don't think you were commenting on
> any of it.  Your whole repl appears to stand alone as a summary of your
> current position.
> 
>> The Turing Machine Halting Problem
>> We begin with some problems...
> 
> It is considered the height of bad manners to quote people without
> attribution.  Innocent readers might think that you wrote this as they
> won't know the golden rule: if it makes sense, it's probably a quote.
> 
>> As required by Definition
>> 12.1, we want H to operate according to the following rules:
>>
>> H.q0  wMw  ⊢*  H.qy
>> H.q0  wMw  ⊢*  H.qn
> 
> But this is worse manners.  Linz did not write those two lines, and the
> lines he did write (the correct ones) were augmented by text that you
> consistently omit, presumably because you don't know how to use his
> notation.  No cookie.
> 
>> We assume the existence of a certain Turing machine F. This machine
>> has several properties.
>> (a) The parameters to F are a Turing machine description and a finite
>> string.
> 
> So not what you wrote above.
> 
>> (b) F simulates its input pair one state transition at a time.
>> (c) F maintains an execution trace list of all of the details of each
>> state transition of the simulation of its input pair.
> 
> A bit vague.  I like the "all the details" so you don't actually have to
> say what you maintain.  After all, you probably don't know what details
> you need yet, so keep them all.
> 
>> (d) After the simulation of each state transition of its input pair H
>> consults this execution trace.
>> (e) F can infallibly detect that an input pair specifies infinite
>> execution as some point in its simulation of its input pair.
> 
> Whoop! whoop! whoop!  Assumed without evidence. 

That is an assumed premise.

>  What's more, I know a
> theorem that states that this is not possible (unless you are using
> PO-words again).
> 
> You have never given any hint as to how a TM computation's sequence of
> configurations can be used to decide halting.  (Infallibly detecting
> infinite execution is the same as deciding halting.)
> 
> You have assumed your desired result and you don't need anything more.
> Once F has infallibly detected non-halting, F can report the result.
> Job done.  Anything else that F does, or that wrap round F is there for
> the purposes of obfuscation only.
> 
>> (g) At the point where F infallibly detects the infinite execution of
>> its input pair F decides to stop simulating its input.
> 

Every finite string that has the property of infinite execution seems to 
contradict this property when it is forced to halt.

> It should enter a rejecting state.  And if, at step (d), the simulated
> computation halts, F should enter an accepting state.  Job done.  F is
> now a halting decider.
> 
> I'll comment on the rest (which is must less clear) if you ask me to,
> but since you seem to be saying that you have (or could have) an
> impossible TM, it seems irrelevant.  The steps (a) to (g) appear to be
> what you have been talking about all along, so I don't see the advantage
> in going into the mucky, unclear bits unless it's really needed.
> 


-- 
Copyright 2021 Pete Olcott

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

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


#31951 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-23 02:56 +0100
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<87sg3hojaz.fsf@bsb.me.uk>
In reply to#31945
olcott <NoOne@NoWhere.com> writes:

> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>> We assume the existence of a certain Turing machine F. This machine
>>> has several properties.
>>> (a) The parameters to F are a Turing machine description and a finite
>>> string.
...
>>> (b) F simulates its input pair one state transition at a time.
>>> (c) F maintains an execution trace list of all of the details of each
>>> state transition of the simulation of its input pair.
...
>>> (d) After the simulation of each state transition of its input pair H
>>> consults this execution trace.
>>> (e) F can infallibly detect that an input pair specifies infinite
>>> execution as some point in its simulation of its input pair.
>>
>> Whoop! whoop! whoop!  Assumed without evidence. 
>
> That is an assumed premise.

You are right.  All of (a) to (g) are part of the initial premise that
such a machine exists.

Do you believe that such a TM exists?  This looks for all the world like
the code sketch you've been discussing (but described as a TM).  It
seems odd to describe such a TM if you know it is impossible.

By the way, it's fine to say you don't know.  You should know, but
you may in fact not know.

>>> (g) At the point where F infallibly detects the infinite execution of
>>> its input pair F decides to stop simulating its input.
>
> Every finite string that has the property of infinite execution seems
> to contradict this property when it is forced to halt.

Does this mean you don't believe that such an F exists?  Note that
you've made a similar claim before:

  "The non-halting decider that I defined accepts any and all
  non-halting inputs and rejects any and all halting inputs."

That's "infallibly detect[ing] the infinite execution of its input".
Are you retracting this claim as well?

>> It should enter a rejecting state.  And if, at step (d), the simulated
>> computation halts, F should enter an accepting state.  Job done.  F is
>> now a halting decider.

-- 
Ben.

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


#31955 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-22 21:10 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<-Z6dnYlSlKgOsR_9nZ2dnUU7-KvNnZ2d@giganews.com>
In reply to#31951
On 4/22/2021 8:56 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>> We assume the existence of a certain Turing machine F. This machine
>>>> has several properties.
>>>> (a) The parameters to F are a Turing machine description and a finite
>>>> string.
> ...
>>>> (b) F simulates its input pair one state transition at a time.
>>>> (c) F maintains an execution trace list of all of the details of each
>>>> state transition of the simulation of its input pair.
> ...
>>>> (d) After the simulation of each state transition of its input pair H
>>>> consults this execution trace.
>>>> (e) F can infallibly detect that an input pair specifies infinite
>>>> execution as some point in its simulation of its input pair.
>>>
>>> Whoop! whoop! whoop!  Assumed without evidence.
>>
>> That is an assumed premise.
> 
> You are right.  All of (a) to (g) are part of the initial premise that
> such a machine exists.
> 
> Do you believe that such a TM exists?  This looks for all the world like
> the code sketch you've been discussing (but described as a TM).  It
> seems odd to describe such a TM if you know it is impossible.
> 
> By the way, it's fine to say you don't know.  You should know, but
> you may in fact not know.
> 

I am only dealing with the H_Hat type of configuration.

>>>> (g) At the point where F infallibly detects the infinite execution of
>>>> its input pair F decides to stop simulating its input.
>>
>> Every finite string that has the property of infinite execution seems
>> to contradict this property when it is forced to halt.
> 
> Does this mean you don't believe that such an F exists?  Note that
> you've made a similar claim before:
> 

I know that My Halts() does correctly decide its H_Hat().

>    "The non-halting decider that I defined accepts any and all
>    non-halting inputs and rejects any and all halting inputs."
> 

There is not an instance of any provably undecidable input for my design 
that I am aware of.

> That's "infallibly detect[ing] the infinite execution of its input".
> Are you retracting this claim as well?
> 
>>> It should enter a rejecting state.  And if, at step (d), the simulated
>>> computation halts, F should enter an accepting state.  Job done.  F is
>>> now a halting decider.
> 


-- 
Copyright 2021 Pete Olcott

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

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


#31962 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-04-22 22:45 -0400
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<SwqgI.20684$b27.11130@fx03.iad>
In reply to#31955
On 4/22/21 10:10 PM, olcott wrote:
> On 4/22/2021 8:56 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>> We assume the existence of a certain Turing machine F. This machine
>>>>> has several properties.
>>>>> (a) The parameters to F are a Turing machine description and a finite
>>>>> string.
>> ...
>>>>> (b) F simulates its input pair one state transition at a time.
>>>>> (c) F maintains an execution trace list of all of the details of each
>>>>> state transition of the simulation of its input pair.
>> ...
>>>>> (d) After the simulation of each state transition of its input pair H
>>>>> consults this execution trace.
>>>>> (e) F can infallibly detect that an input pair specifies infinite
>>>>> execution as some point in its simulation of its input pair.
>>>>
>>>> Whoop! whoop! whoop!  Assumed without evidence.
>>>
>>> That is an assumed premise.
>>
>> You are right.  All of (a) to (g) are part of the initial premise that
>> such a machine exists.
>>
>> Do you believe that such a TM exists?  This looks for all the world like
>> the code sketch you've been discussing (but described as a TM).  It
>> seems odd to describe such a TM if you know it is impossible.
>>
>> By the way, it's fine to say you don't know.  You should know, but
>> you may in fact not know.
>>
> 
> I am only dealing with the H_Hat type of configuration.
> 
>>>>> (g) At the point where F infallibly detects the infinite execution of
>>>>> its input pair F decides to stop simulating its input.
>>>
>>> Every finite string that has the property of infinite execution seems
>>> to contradict this property when it is forced to halt.
>>
>> Does this mean you don't believe that such an F exists?  Note that
>> you've made a similar claim before:
>>
> 
> I know that My Halts() does correctly decide its H_Hat().

Maybe you 'know' it, but you are wrong, either that or Halts() doesn't
meet the requirements to be a Decider by Computation Theory, or H_Hat
isn't built by the pattern of Linz or Sipser.

> 
>>    "The non-halting decider that I defined accepts any and all
>>    non-halting inputs and rejects any and all halting inputs."
>>
> 
> There is not an instance of any provably undecidable input for my design
> that I am aware of.

Again, you are wrong. H_Hat by Sipser or Linz.

> 
>> That's "infallibly detect[ing] the infinite execution of its input".
>> Are you retracting this claim as well?
>>
>>>> It should enter a rejecting state.  And if, at step (d), the simulated
>>>> computation halts, F should enter an accepting state.  Job done.  F is
>>>> now a halting decider.
>>
> 
> 

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


#31968 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-22 22:19 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<aJadnbIhtJQwoR_9nZ2dnUU7-dGdnZ2d@giganews.com>
In reply to#31962
On 4/22/2021 9:45 PM, Richard Damon wrote:
> On 4/22/21 10:10 PM, olcott wrote:
>> On 4/22/2021 8:56 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>> We assume the existence of a certain Turing machine F. This machine
>>>>>> has several properties.
>>>>>> (a) The parameters to F are a Turing machine description and a finite
>>>>>> string.
>>> ...
>>>>>> (b) F simulates its input pair one state transition at a time.
>>>>>> (c) F maintains an execution trace list of all of the details of each
>>>>>> state transition of the simulation of its input pair.
>>> ...
>>>>>> (d) After the simulation of each state transition of its input pair H
>>>>>> consults this execution trace.
>>>>>> (e) F can infallibly detect that an input pair specifies infinite
>>>>>> execution as some point in its simulation of its input pair.
>>>>>
>>>>> Whoop! whoop! whoop!  Assumed without evidence.
>>>>
>>>> That is an assumed premise.
>>>
>>> You are right.  All of (a) to (g) are part of the initial premise that
>>> such a machine exists.
>>>
>>> Do you believe that such a TM exists?  This looks for all the world like
>>> the code sketch you've been discussing (but described as a TM).  It
>>> seems odd to describe such a TM if you know it is impossible.
>>>
>>> By the way, it's fine to say you don't know.  You should know, but
>>> you may in fact not know.
>>>
>>
>> I am only dealing with the H_Hat type of configuration.
>>
>>>>>> (g) At the point where F infallibly detects the infinite execution of
>>>>>> its input pair F decides to stop simulating its input.
>>>>
>>>> Every finite string that has the property of infinite execution seems
>>>> to contradict this property when it is forced to halt.
>>>
>>> Does this mean you don't believe that such an F exists?  Note that
>>> you've made a similar claim before:
>>>
>>
>> I know that My Halts() does correctly decide its H_Hat().
> 
> Maybe you 'know' it, but you are wrong, either that or Halts() doesn't
> meet the requirements to be a Decider by Computation Theory, or H_Hat
> isn't built by the pattern of Linz or Sipser.
> 

You are wrong on both these points.

-- 
Copyright 2021 Pete Olcott

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

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


#31977 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-04-23 07:43 -0400
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<rpygI.79220$OF5.16492@fx07.iad>
In reply to#31968
On 4/22/21 11:19 PM, olcott wrote:
> On 4/22/2021 9:45 PM, Richard Damon wrote:
>> On 4/22/21 10:10 PM, olcott wrote:
>>> On 4/22/2021 8:56 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>> We assume the existence of a certain Turing machine F. This machine
>>>>>>> has several properties.
>>>>>>> (a) The parameters to F are a Turing machine description and a
>>>>>>> finite
>>>>>>> string.
>>>> ...
>>>>>>> (b) F simulates its input pair one state transition at a time.
>>>>>>> (c) F maintains an execution trace list of all of the details of
>>>>>>> each
>>>>>>> state transition of the simulation of its input pair.
>>>> ...
>>>>>>> (d) After the simulation of each state transition of its input
>>>>>>> pair H
>>>>>>> consults this execution trace.
>>>>>>> (e) F can infallibly detect that an input pair specifies infinite
>>>>>>> execution as some point in its simulation of its input pair.
>>>>>>
>>>>>> Whoop! whoop! whoop!  Assumed without evidence.
>>>>>
>>>>> That is an assumed premise.
>>>>
>>>> You are right.  All of (a) to (g) are part of the initial premise that
>>>> such a machine exists.
>>>>
>>>> Do you believe that such a TM exists?  This looks for all the world
>>>> like
>>>> the code sketch you've been discussing (but described as a TM).  It
>>>> seems odd to describe such a TM if you know it is impossible.
>>>>
>>>> By the way, it's fine to say you don't know.  You should know, but
>>>> you may in fact not know.
>>>>
>>>
>>> I am only dealing with the H_Hat type of configuration.
>>>
>>>>>>> (g) At the point where F infallibly detects the infinite
>>>>>>> execution of
>>>>>>> its input pair F decides to stop simulating its input.
>>>>>
>>>>> Every finite string that has the property of infinite execution seems
>>>>> to contradict this property when it is forced to halt.
>>>>
>>>> Does this mean you don't believe that such an F exists?  Note that
>>>> you've made a similar claim before:
>>>>
>>>
>>> I know that My Halts() does correctly decide its H_Hat().
>>
>> Maybe you 'know' it, but you are wrong, either that or Halts() doesn't
>> meet the requirements to be a Decider by Computation Theory, or H_Hat
>> isn't built by the pattern of Linz or Sipser.
>>
> 
> You are wrong on both these points.
> 

WRONG. Find the error:

1) Halts is stipulated to meet the requirements of a Halt Decider.

2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat) when
asked direction

3) H_Hat is stipulated to be built like Linz.

4) 1 Means that Halts is a Computation, and will always return the same
answer (or never return an answer) for a given input.

5) H_Hat when run as a Machine will perform the Computation Halts(H_Hat,
H_Hat)

6) by 4 and 2, this means that Halts will return the decision on
non-halting to H_Hat

7) By 3, this means that H_Hat will Halt.

8) This means that H_Hat is a Halting Computation, and becuase of 2, it
is wrong.

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


#31979 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-23 09:19 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<bOSdnTwW74ynSh_9nZ2dnUU7-RednZ2d@giganews.com>
In reply to#31977
On 4/23/2021 6:43 AM, Richard Damon wrote:
> On 4/22/21 11:19 PM, olcott wrote:
>> On 4/22/2021 9:45 PM, Richard Damon wrote:
>>> On 4/22/21 10:10 PM, olcott wrote:
>>>> On 4/22/2021 8:56 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>> We assume the existence of a certain Turing machine F. This machine
>>>>>>>> has several properties.
>>>>>>>> (a) The parameters to F are a Turing machine description and a
>>>>>>>> finite
>>>>>>>> string.
>>>>> ...
>>>>>>>> (b) F simulates its input pair one state transition at a time.
>>>>>>>> (c) F maintains an execution trace list of all of the details of
>>>>>>>> each
>>>>>>>> state transition of the simulation of its input pair.
>>>>> ...
>>>>>>>> (d) After the simulation of each state transition of its input
>>>>>>>> pair H
>>>>>>>> consults this execution trace.
>>>>>>>> (e) F can infallibly detect that an input pair specifies infinite
>>>>>>>> execution as some point in its simulation of its input pair.
>>>>>>>
>>>>>>> Whoop! whoop! whoop!  Assumed without evidence.
>>>>>>
>>>>>> That is an assumed premise.
>>>>>
>>>>> You are right.  All of (a) to (g) are part of the initial premise that
>>>>> such a machine exists.
>>>>>
>>>>> Do you believe that such a TM exists?  This looks for all the world
>>>>> like
>>>>> the code sketch you've been discussing (but described as a TM).  It
>>>>> seems odd to describe such a TM if you know it is impossible.
>>>>>
>>>>> By the way, it's fine to say you don't know.  You should know, but
>>>>> you may in fact not know.
>>>>>
>>>>
>>>> I am only dealing with the H_Hat type of configuration.
>>>>
>>>>>>>> (g) At the point where F infallibly detects the infinite
>>>>>>>> execution of
>>>>>>>> its input pair F decides to stop simulating its input.
>>>>>>
>>>>>> Every finite string that has the property of infinite execution seems
>>>>>> to contradict this property when it is forced to halt.
>>>>>
>>>>> Does this mean you don't believe that such an F exists?  Note that
>>>>> you've made a similar claim before:
>>>>>
>>>>
>>>> I know that My Halts() does correctly decide its H_Hat().
>>>
>>> Maybe you 'know' it, but you are wrong, either that or Halts() doesn't
>>> meet the requirements to be a Decider by Computation Theory, or H_Hat
>>> isn't built by the pattern of Linz or Sipser.
>>>
>>
>> You are wrong on both these points.
>>
> 
> WRONG. Find the error:
> 
> 1) Halts is stipulated to meet the requirements of a Halt Decider.
> 
> 2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat) when
> asked direction
> 
> 3) H_Hat is stipulated to be built like Linz.
> 
> 4) 1 Means that Halts is a Computation, and will always return the same
> answer (or never return an answer) for a given input.
> 
> 5) H_Hat when run as a Machine will perform the Computation Halts(H_Hat,
> H_Hat)
> 
> 6) by 4 and 2, this means that Halts will return the decision on
> non-halting to H_Hat
> 
> 7) By 3, this means that H_Hat will Halt.
> 
> 8) This means that H_Hat is a Halting Computation, and becuase of 2, it
> is wrong.
> 

This part is simply over your head.

-- 
Copyright 2021 Pete Olcott

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

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


#31986 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-04-23 11:19 -0400
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<IzBgI.10304$AU5.675@fx29.iad>
In reply to#31979
On 4/23/21 10:19 AM, olcott wrote:
> On 4/23/2021 6:43 AM, Richard Damon wrote:
>> On 4/22/21 11:19 PM, olcott wrote:
>>> On 4/22/2021 9:45 PM, Richard Damon wrote:
>>>> On 4/22/21 10:10 PM, olcott wrote:
>>>>> On 4/22/2021 8:56 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>> We assume the existence of a certain Turing machine F. This
>>>>>>>>> machine
>>>>>>>>> has several properties.
>>>>>>>>> (a) The parameters to F are a Turing machine description and a
>>>>>>>>> finite
>>>>>>>>> string.
>>>>>> ...
>>>>>>>>> (b) F simulates its input pair one state transition at a time.
>>>>>>>>> (c) F maintains an execution trace list of all of the details of
>>>>>>>>> each
>>>>>>>>> state transition of the simulation of its input pair.
>>>>>> ...
>>>>>>>>> (d) After the simulation of each state transition of its input
>>>>>>>>> pair H
>>>>>>>>> consults this execution trace.
>>>>>>>>> (e) F can infallibly detect that an input pair specifies infinite
>>>>>>>>> execution as some point in its simulation of its input pair.
>>>>>>>>
>>>>>>>> Whoop! whoop! whoop!  Assumed without evidence.
>>>>>>>
>>>>>>> That is an assumed premise.
>>>>>>
>>>>>> You are right.  All of (a) to (g) are part of the initial premise
>>>>>> that
>>>>>> such a machine exists.
>>>>>>
>>>>>> Do you believe that such a TM exists?  This looks for all the world
>>>>>> like
>>>>>> the code sketch you've been discussing (but described as a TM).  It
>>>>>> seems odd to describe such a TM if you know it is impossible.
>>>>>>
>>>>>> By the way, it's fine to say you don't know.  You should know, but
>>>>>> you may in fact not know.
>>>>>>
>>>>>
>>>>> I am only dealing with the H_Hat type of configuration.
>>>>>
>>>>>>>>> (g) At the point where F infallibly detects the infinite
>>>>>>>>> execution of
>>>>>>>>> its input pair F decides to stop simulating its input.
>>>>>>>
>>>>>>> Every finite string that has the property of infinite execution
>>>>>>> seems
>>>>>>> to contradict this property when it is forced to halt.
>>>>>>
>>>>>> Does this mean you don't believe that such an F exists?  Note that
>>>>>> you've made a similar claim before:
>>>>>>
>>>>>
>>>>> I know that My Halts() does correctly decide its H_Hat().
>>>>
>>>> Maybe you 'know' it, but you are wrong, either that or Halts() doesn't
>>>> meet the requirements to be a Decider by Computation Theory, or H_Hat
>>>> isn't built by the pattern of Linz or Sipser.
>>>>
>>>
>>> You are wrong on both these points.
>>>
>>
>> WRONG. Find the error:
>>
>> 1) Halts is stipulated to meet the requirements of a Halt Decider.
>>
>> 2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat) when
>> asked direction
>>
>> 3) H_Hat is stipulated to be built like Linz.
>>
>> 4) 1 Means that Halts is a Computation, and will always return the same
>> answer (or never return an answer) for a given input.
>>
>> 5) H_Hat when run as a Machine will perform the Computation Halts(H_Hat,
>> H_Hat)
>>
>> 6) by 4 and 2, this means that Halts will return the decision on
>> non-halting to H_Hat
>>
>> 7) By 3, this means that H_Hat will Halt.
>>
>> 8) This means that H_Hat is a Halting Computation, and becuase of 2, it
>> is wrong.
>>
> 
> This part is simply over your head.
> 

Computation Theory seems to be above yours.

No flaws noted, argument stands, your arguement debunked.

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


#31992 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-23 10:48 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<SOmdnTEZ4fatcR_9nZ2dnUU7-b3NnZ2d@giganews.com>
In reply to#31986
On 4/23/2021 10:19 AM, Richard Damon wrote:
> On 4/23/21 10:19 AM, olcott wrote:
>> On 4/23/2021 6:43 AM, Richard Damon wrote:
>>> On 4/22/21 11:19 PM, olcott wrote:
>>>> On 4/22/2021 9:45 PM, Richard Damon wrote:
>>>>> On 4/22/21 10:10 PM, olcott wrote:
>>>>>> On 4/22/2021 8:56 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>> We assume the existence of a certain Turing machine F. This
>>>>>>>>>> machine
>>>>>>>>>> has several properties.
>>>>>>>>>> (a) The parameters to F are a Turing machine description and a
>>>>>>>>>> finite
>>>>>>>>>> string.
>>>>>>> ...
>>>>>>>>>> (b) F simulates its input pair one state transition at a time.
>>>>>>>>>> (c) F maintains an execution trace list of all of the details of
>>>>>>>>>> each
>>>>>>>>>> state transition of the simulation of its input pair.
>>>>>>> ...
>>>>>>>>>> (d) After the simulation of each state transition of its input
>>>>>>>>>> pair H
>>>>>>>>>> consults this execution trace.
>>>>>>>>>> (e) F can infallibly detect that an input pair specifies infinite
>>>>>>>>>> execution as some point in its simulation of its input pair.
>>>>>>>>>
>>>>>>>>> Whoop! whoop! whoop!  Assumed without evidence.
>>>>>>>>
>>>>>>>> That is an assumed premise.
>>>>>>>
>>>>>>> You are right.  All of (a) to (g) are part of the initial premise
>>>>>>> that
>>>>>>> such a machine exists.
>>>>>>>
>>>>>>> Do you believe that such a TM exists?  This looks for all the world
>>>>>>> like
>>>>>>> the code sketch you've been discussing (but described as a TM).  It
>>>>>>> seems odd to describe such a TM if you know it is impossible.
>>>>>>>
>>>>>>> By the way, it's fine to say you don't know.  You should know, but
>>>>>>> you may in fact not know.
>>>>>>>
>>>>>>
>>>>>> I am only dealing with the H_Hat type of configuration.
>>>>>>
>>>>>>>>>> (g) At the point where F infallibly detects the infinite
>>>>>>>>>> execution of
>>>>>>>>>> its input pair F decides to stop simulating its input.
>>>>>>>>
>>>>>>>> Every finite string that has the property of infinite execution
>>>>>>>> seems
>>>>>>>> to contradict this property when it is forced to halt.
>>>>>>>
>>>>>>> Does this mean you don't believe that such an F exists?  Note that
>>>>>>> you've made a similar claim before:
>>>>>>>
>>>>>>
>>>>>> I know that My Halts() does correctly decide its H_Hat().
>>>>>
>>>>> Maybe you 'know' it, but you are wrong, either that or Halts() doesn't
>>>>> meet the requirements to be a Decider by Computation Theory, or H_Hat
>>>>> isn't built by the pattern of Linz or Sipser.
>>>>>
>>>>
>>>> You are wrong on both these points.
>>>>
>>>
>>> WRONG. Find the error:
>>>
>>> 1) Halts is stipulated to meet the requirements of a Halt Decider.
>>>
>>> 2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat) when
>>> asked direction
>>>

So a halt decide is only correct when it asks you whether or not it 
should make a left hand turn? (asked direction)

>>> 3) H_Hat is stipulated to be built like Linz.
>>>

I am building is like Sipser says which is not like what you assume that 
he means.

>>> 4) 1 Means that Halts is a Computation, and will always return the same
>>> answer (or never return an answer) for a given input.
>>>
>>> 5) H_Hat when run as a Machine will perform the Computation Halts(H_Hat,
>>> H_Hat)
>>>
>>> 6) by 4 and 2, this means that Halts will return the decision on
>>> non-halting to H_Hat
>>>
>>> 7) By 3, this means that H_Hat will Halt.
>>>

(8) is wrong. You have brain damage on this key element.
That is very strange because this may be the only element that you just
can't seem to understand.

>>> 8) This means that H_Hat is a Halting Computation, and becuase of 2, it
>>> is wrong.
>>>
>>
>> This part is simply over your head.
>>
> 
> Computation Theory seems to be above yours.
> 
> No flaws noted, argument stands, your arguement debunked.
> 

-- 
Copyright 2021 Pete Olcott

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

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


#31999 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-04-23 12:22 -0400
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<BvCgI.37223$gq3.17129@fx04.iad>
In reply to#31992
On 4/23/21 11:48 AM, olcott wrote:
> On 4/23/2021 10:19 AM, Richard Damon wrote:
>> On 4/23/21 10:19 AM, olcott wrote:
>>> On 4/23/2021 6:43 AM, Richard Damon wrote:
>>>> On 4/22/21 11:19 PM, olcott wrote:
>>>>> On 4/22/2021 9:45 PM, Richard Damon wrote:
>>>>>> On 4/22/21 10:10 PM, olcott wrote:
>>>>>>> On 4/22/2021 8:56 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>> We assume the existence of a certain Turing machine F. This
>>>>>>>>>>> machine
>>>>>>>>>>> has several properties.
>>>>>>>>>>> (a) The parameters to F are a Turing machine description and a
>>>>>>>>>>> finite
>>>>>>>>>>> string.
>>>>>>>> ...
>>>>>>>>>>> (b) F simulates its input pair one state transition at a time.
>>>>>>>>>>> (c) F maintains an execution trace list of all of the details of
>>>>>>>>>>> each
>>>>>>>>>>> state transition of the simulation of its input pair.
>>>>>>>> ...
>>>>>>>>>>> (d) After the simulation of each state transition of its input
>>>>>>>>>>> pair H
>>>>>>>>>>> consults this execution trace.
>>>>>>>>>>> (e) F can infallibly detect that an input pair specifies
>>>>>>>>>>> infinite
>>>>>>>>>>> execution as some point in its simulation of its input pair.
>>>>>>>>>>
>>>>>>>>>> Whoop! whoop! whoop!  Assumed without evidence.
>>>>>>>>>
>>>>>>>>> That is an assumed premise.
>>>>>>>>
>>>>>>>> You are right.  All of (a) to (g) are part of the initial premise
>>>>>>>> that
>>>>>>>> such a machine exists.
>>>>>>>>
>>>>>>>> Do you believe that such a TM exists?  This looks for all the world
>>>>>>>> like
>>>>>>>> the code sketch you've been discussing (but described as a TM).  It
>>>>>>>> seems odd to describe such a TM if you know it is impossible.
>>>>>>>>
>>>>>>>> By the way, it's fine to say you don't know.  You should know, but
>>>>>>>> you may in fact not know.
>>>>>>>>
>>>>>>>
>>>>>>> I am only dealing with the H_Hat type of configuration.
>>>>>>>
>>>>>>>>>>> (g) At the point where F infallibly detects the infinite
>>>>>>>>>>> execution of
>>>>>>>>>>> its input pair F decides to stop simulating its input.
>>>>>>>>>
>>>>>>>>> Every finite string that has the property of infinite execution
>>>>>>>>> seems
>>>>>>>>> to contradict this property when it is forced to halt.
>>>>>>>>
>>>>>>>> Does this mean you don't believe that such an F exists?  Note that
>>>>>>>> you've made a similar claim before:
>>>>>>>>
>>>>>>>
>>>>>>> I know that My Halts() does correctly decide its H_Hat().
>>>>>>
>>>>>> Maybe you 'know' it, but you are wrong, either that or Halts()
>>>>>> doesn't
>>>>>> meet the requirements to be a Decider by Computation Theory, or H_Hat
>>>>>> isn't built by the pattern of Linz or Sipser.
>>>>>>
>>>>>
>>>>> You are wrong on both these points.
>>>>>
>>>>
>>>> WRONG. Find the error:
>>>>
>>>> 1) Halts is stipulated to meet the requirements of a Halt Decider.
>>>>
>>>> 2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat)
>>>> when
>>>> asked direction
>>>>
> 
> So a halt decide is only correct when it asks you whether or not it
> should make a left hand turn? (asked direction)

So you disagree that Halts returns non-halting?

> 
>>>> 3) H_Hat is stipulated to be built like Linz.
>>>>
> 
> I am building is like Sipser says which is not like what you assume that
> he means.
> 

Ok then:
3) H_Hat is stipulated to be built like Linz or Sipser, in that it will
halt when the Halt decider it is built on decides non-Halting.


>>>> 4) 1 Means that Halts is a Computation, and will always return the same
>>>> answer (or never return an answer) for a given input.
>>>>
>>>> 5) H_Hat when run as a Machine will perform the Computation
>>>> Halts(H_Hat,
>>>> H_Hat)
>>>>
>>>> 6) by 4 and 2, this means that Halts will return the decision on
>>>> non-halting to H_Hat
>>>>
>>>> 7) By 3, this means that H_Hat will Halt.
>>>>
> 
> (8) is wrong. You have brain damage on this key element.
> That is very strange because this may be the only element that you just
> can't seem to understand.

So, you say a Computation as proven in 7 will halt is not a Halting
Computation? Strange definition of Halting, and not compatible with
Computation Theory.

> 
>>>> 8) This means that H_Hat is a Halting Computation, and becuase of 2, it
>>>> is wrong.
>>>>
>>>
>>> This part is simply over your head.
>>>
>>
>> Computation Theory seems to be above yours.
>>
>> No flaws noted, argument stands, your arguement debunked.
>>
> 

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


#32005 — Re: Infinite recursion detection criteria: (equivalent definitions)(easier?)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-23 11:37 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<qeudnWDR8JNfah_9nZ2dnUU78RfNnZ2d@giganews.com>
In reply to#31999
On 4/23/2021 11:22 AM, Richard Damon wrote:
> On 4/23/21 11:48 AM, olcott wrote:
>> On 4/23/2021 10:19 AM, Richard Damon wrote:
>>> On 4/23/21 10:19 AM, olcott wrote:
>>>> On 4/23/2021 6:43 AM, Richard Damon wrote:
>>>>> On 4/22/21 11:19 PM, olcott wrote:
>>>>>> On 4/22/2021 9:45 PM, Richard Damon wrote:
>>>>>>> On 4/22/21 10:10 PM, olcott wrote:
>>>>>>>> On 4/22/2021 8:56 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/22/2021 6:41 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>> We assume the existence of a certain Turing machine F. This
>>>>>>>>>>>> machine
>>>>>>>>>>>> has several properties.
>>>>>>>>>>>> (a) The parameters to F are a Turing machine description and a
>>>>>>>>>>>> finite
>>>>>>>>>>>> string.
>>>>>>>>> ...
>>>>>>>>>>>> (b) F simulates its input pair one state transition at a time.
>>>>>>>>>>>> (c) F maintains an execution trace list of all of the details of
>>>>>>>>>>>> each
>>>>>>>>>>>> state transition of the simulation of its input pair.
>>>>>>>>> ...
>>>>>>>>>>>> (d) After the simulation of each state transition of its input
>>>>>>>>>>>> pair H
>>>>>>>>>>>> consults this execution trace.
>>>>>>>>>>>> (e) F can infallibly detect that an input pair specifies
>>>>>>>>>>>> infinite
>>>>>>>>>>>> execution as some point in its simulation of its input pair.
>>>>>>>>>>>
>>>>>>>>>>> Whoop! whoop! whoop!  Assumed without evidence.
>>>>>>>>>>
>>>>>>>>>> That is an assumed premise.
>>>>>>>>>
>>>>>>>>> You are right.  All of (a) to (g) are part of the initial premise
>>>>>>>>> that
>>>>>>>>> such a machine exists.
>>>>>>>>>
>>>>>>>>> Do you believe that such a TM exists?  This looks for all the world
>>>>>>>>> like
>>>>>>>>> the code sketch you've been discussing (but described as a TM).  It
>>>>>>>>> seems odd to describe such a TM if you know it is impossible.
>>>>>>>>>
>>>>>>>>> By the way, it's fine to say you don't know.  You should know, but
>>>>>>>>> you may in fact not know.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am only dealing with the H_Hat type of configuration.
>>>>>>>>
>>>>>>>>>>>> (g) At the point where F infallibly detects the infinite
>>>>>>>>>>>> execution of
>>>>>>>>>>>> its input pair F decides to stop simulating its input.
>>>>>>>>>>
>>>>>>>>>> Every finite string that has the property of infinite execution
>>>>>>>>>> seems
>>>>>>>>>> to contradict this property when it is forced to halt.
>>>>>>>>>
>>>>>>>>> Does this mean you don't believe that such an F exists?  Note that
>>>>>>>>> you've made a similar claim before:
>>>>>>>>>
>>>>>>>>
>>>>>>>> I know that My Halts() does correctly decide its H_Hat().
>>>>>>>
>>>>>>> Maybe you 'know' it, but you are wrong, either that or Halts()
>>>>>>> doesn't
>>>>>>> meet the requirements to be a Decider by Computation Theory, or H_Hat
>>>>>>> isn't built by the pattern of Linz or Sipser.
>>>>>>>
>>>>>>
>>>>>> You are wrong on both these points.
>>>>>>
>>>>>
>>>>> WRONG. Find the error:
>>>>>
>>>>> 1) Halts is stipulated to meet the requirements of a Halt Decider.
>>>>>
>>>>> 2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat)
>>>>> when
>>>>> asked direction
>>>>>
>>
>> So a halt decide is only correct when it asks you whether or not it
>> should make a left hand turn? (asked direction)
> 
> So you disagree that Halts returns non-halting?
> 
>>
>>>>> 3) H_Hat is stipulated to be built like Linz.
>>>>>
>>
>> I am building is like Sipser says which is not like what you assume that
>> he means.
>>
> 
> Ok then:
> 3) H_Hat is stipulated to be built like Linz or Sipser, in that it will
> halt when the Halt decider it is built on decides non-Halting.
> 

     PROOF We assume that ATM is decidable and obtain a
     contradiction. Suppose that H is a decider for ATM.

     Now we construct a new Turing machine D with H as a
     subroutine. This new TM calls H to determine what M
     does when the input to M is its own description <M>.
     Once D has determined this information, it does the
     opposite.

Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: 
PWS Publishing Company (165-167)


> 
>>>>> 4) 1 Means that Halts is a Computation, and will always return the same
>>>>> answer (or never return an answer) for a given input.
>>>>>
>>>>> 5) H_Hat when run as a Machine will perform the Computation
>>>>> Halts(H_Hat,
>>>>> H_Hat)
>>>>>
>>>>> 6) by 4 and 2, this means that Halts will return the decision on
>>>>> non-halting to H_Hat
>>>>>
>>>>> 7) By 3, this means that H_Hat will Halt.
>>>>>
>>
>> (8) is wrong. You have brain damage on this key element.
>> That is very strange because this may be the only element that you just
>> can't seem to understand.
> 
> So, you say a Computation as proven in 7 will halt is not a Halting
> Computation? Strange definition of Halting, and not compatible with
> Computation Theory.
> 

A finite string specifying an infinite loop has the property of infinite 
execution

even though the halt decider terminates this loop to report the non 
halting property of this infinite loop.

>>
>>>>> 8) This means that H_Hat is a Halting Computation, and becuase of 2, it
>>>>> is wrong.
>>>>>
>>>>
>>>> This part is simply over your head.
>>>>
>>>
>>> Computation Theory seems to be above yours.
>>>
>>> No flaws noted, argument stands, your arguement debunked.
>>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


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

Back to top | Article view | comp.theory


csiph-web