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


#31644 — Re: Infinite recursion detection criteria: (equivalent definitions)

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-04-20 13:31 -0700
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<9bb48d56-14c3-4cdd-922c-e58cf959c6ccn@googlegroups.com>
In reply to#31627
On Tuesday, 20 April 2021 at 20:22:49 UTC+1, olcott wrote:
> On 4/20/2021 1:27 PM, Ben Bacarisse wrote: 
> > olcott <No...@NoWhere.com> writes: 
> > 
> >> On 4/20/2021 6:00 AM, Ben Bacarisse wrote: 
> >>> olcott <No...@NoWhere.com> writes: 
> >>> 
> >>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote: 
> >>>>> olcott <No...@NoWhere.com> writes: 
> >>>>> 
> >>>>>> On 4/19/2021 9:53 PM, Ben Bacarisse wrote: 
> >>>>>>> olcott <polc...@gmail.com> writes: 
> >>>>>>> 
> >>>>>>>> On 4/19/2021 5:44 PM, Ben Bacarisse wrote: 
> >>>>>>>>> olcott <No...@NoWhere.com> writes: 
> >>>>>>>>> 
> >>>>>>>>> I explained this fundamental mistake months ago. You accept the facts, 
> >>>>>>>>> you just pretend that the wrong answer is "PO-correct": 
> >>>>>>>>> 
> >>>>>>>>> You told me (in response to my "challenge" last year) that 
> >>>>>>>>> 
> >>>>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and 
> >>>>>>>>> (b) the input to Halts is finite. 
> >>>>>>>>> 
> >>>>>>>>> (by which you meant the input represents a finite computation). 
> >>>>>>>>> 
> >>>>>>>>> I don't think there is any disagreement about this. The problem is just 
> >>>>>>>>> that you don't like it being drawn into the light. 
> >>>>>>>> 
> >>>>>>>> The machine language of the input to Halts does specify infinite 
> >>>>>>>> recursion when this input to Halts and Halts are not conflated 
> >>>>>>>> together as a single computation. 
> >>>>>>> 
> >>>>>>> But when Confound_Halts is correctly constructed, the input to Halts 
> >>>>>>> represents, as you told me, a finite computation. 
> >>>>>> 
> >>>>>> I can transform one definition into another equivalent definition. 
> >>>>>> 
> >>>>>> Whether or not a simulated input must have its simulation aborted to 
> >>>>>> prevent its infinite execution <is> equivalent to deciding that an 
> >>>>>> input has infinite execution because (a) and (b) 
> >>>>>> 
> >>>>>> (a) Every input having infinite execution would have to have its 
> >>>>>> simulation aborted to prevent its otherwise infinite execution. 
> >>>>>> 
> >>>>>> (b) Every input not having infinite execution need not have its 
> >>>>>> simulation aborted to prevent infinite execution 
> >>>>> 
> >>>>> Confound_Halts(Confound_Halts) is a finite computation (according to 
> >>>>> you). It's in category (b). It does not need to have its simulation 
> >>>>> aborted to prevent infinite execution. It is a finite computation 
> >>>>> because, according to you, Halts(Confound_Halts, Confound_Halts) returns 
> >>>>> false and in that case Confound_Halts returns immediately. 
> >>>>> 
> >>>>>> Thus the set of inputs that must be aborted to prevent their infinite 
> >>>>>> execution is the exact same set of inputs that have infinite 
> >>>>>> execution. 
> >>>>> 
> >>>>> Confound_Halts(Confound_Halts) is not one of those. It is, according to 
> >>>>> you, a finite computation. That ties up with the fact that, according 
> >>>>> to you, Halts(Confound_Halts, Confound_Halts) returns false, because in 
> >>>>> that case Confound_Halts simply returns. 
> >>>>> 
> >>>>> The only problem is that false is the wrong answer for a finite 
> >>>>> computation. 
> >>>> 
> >>>> This must be over your head: 
> >>>> When set Q has the same members as set R then we can know that the 
> >>>> definition of set Q is equivalent to the definition of set R. 
> >>> 
> >>> So you don't dispute any of the facts. 
> >> 
> >> That fact has finally been made moot. 
> >> 
> >> I can transform one definition into another equivalent definition. 
> > 
> > Well that simplifies things.
> When it is proven that set Q has the exactly same elements as set R then 
> this proves that the definition of set Q is equivalent to the definition 
> of set R.
>
Two definitions might describe the same set by accident. For instance the set of
animals with fur, and the set of animals that suckle their young. These both
describe the mammals. But it would be logically possible to have a species which 
has only one of those characteristics. In fact, there isn't an example.

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


#31656 — Re: Infinite recursion detection criteria: (equivalent definitions)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-20 15:57 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<N5idnYaf04DX3eL9nZ2dnUU7-IGdnZ2d@giganews.com>
In reply to#31644
On 4/20/2021 3:31 PM, Malcolm McLean wrote:
> On Tuesday, 20 April 2021 at 20:22:49 UTC+1, olcott wrote:
>> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>>> olcott <No...@NoWhere.com> writes:
>>>
>>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>>> olcott <No...@NoWhere.com> writes:
>>>>>
>>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/19/2021 9:53 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/19/2021 5:44 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>> I explained this fundamental mistake months ago. You accept the facts,
>>>>>>>>>>> you just pretend that the wrong answer is "PO-correct":
>>>>>>>>>>>
>>>>>>>>>>> You told me (in response to my "challenge" last year) that
>>>>>>>>>>>
>>>>>>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>>>>>>>>> (b) the input to Halts is finite.
>>>>>>>>>>>
>>>>>>>>>>> (by which you meant the input represents a finite computation).
>>>>>>>>>>>
>>>>>>>>>>> I don't think there is any disagreement about this. The problem is just
>>>>>>>>>>> that you don't like it being drawn into the light.
>>>>>>>>>>
>>>>>>>>>> The machine language of the input to Halts does specify infinite
>>>>>>>>>> recursion when this input to Halts and Halts are not conflated
>>>>>>>>>> together as a single computation.
>>>>>>>>>
>>>>>>>>> But when Confound_Halts is correctly constructed, the input to Halts
>>>>>>>>> represents, as you told me, a finite computation.
>>>>>>>>
>>>>>>>> I can transform one definition into another equivalent definition.
>>>>>>>>
>>>>>>>> Whether or not a simulated input must have its simulation aborted to
>>>>>>>> prevent its infinite execution <is> equivalent to deciding that an
>>>>>>>> input has infinite execution because (a) and (b)
>>>>>>>>
>>>>>>>> (a) Every input having infinite execution would have to have its
>>>>>>>> simulation aborted to prevent its otherwise infinite execution.
>>>>>>>>
>>>>>>>> (b) Every input not having infinite execution need not have its
>>>>>>>> simulation aborted to prevent infinite execution
>>>>>>>
>>>>>>> Confound_Halts(Confound_Halts) is a finite computation (according to
>>>>>>> you). It's in category (b). It does not need to have its simulation
>>>>>>> aborted to prevent infinite execution. It is a finite computation
>>>>>>> because, according to you, Halts(Confound_Halts, Confound_Halts) returns
>>>>>>> false and in that case Confound_Halts returns immediately.
>>>>>>>
>>>>>>>> Thus the set of inputs that must be aborted to prevent their infinite
>>>>>>>> execution is the exact same set of inputs that have infinite
>>>>>>>> execution.
>>>>>>>
>>>>>>> Confound_Halts(Confound_Halts) is not one of those. It is, according to
>>>>>>> you, a finite computation. That ties up with the fact that, according
>>>>>>> to you, Halts(Confound_Halts, Confound_Halts) returns false, because in
>>>>>>> that case Confound_Halts simply returns.
>>>>>>>
>>>>>>> The only problem is that false is the wrong answer for a finite
>>>>>>> computation.
>>>>>>
>>>>>> This must be over your head:
>>>>>> When set Q has the same members as set R then we can know that the
>>>>>> definition of set Q is equivalent to the definition of set R.
>>>>>
>>>>> So you don't dispute any of the facts.
>>>>
>>>> That fact has finally been made moot.
>>>>
>>>> I can transform one definition into another equivalent definition.
>>>
>>> Well that simplifies things.
>> When it is proven that set Q has the exactly same elements as set R then
>> this proves that the definition of set Q is equivalent to the definition
>> of set R.
>>
> Two definitions might describe the same set by accident.

As long as two different definitions define the same set of elements 
then this proves that the definitions are equivalent.


-- 
Copyright 2021 Pete Olcott

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

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


#31668 — Re: Infinite recursion detection criteria: (equivalent definitions)

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

> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
<cut>
>>>>>> The only problem is that false is the wrong answer for a finite
>>>>>> computation.
>>>>>
>>>>> This must be over your head:
>>>>> When set Q has the same members as set R then we can know that the
>>>>> definition of set Q is equivalent to the definition of set R.
>>>>
>>>> So you don't dispute any of the facts.
>>>
>>> That fact has finally been made moot.
>>>
>>> I can transform one definition into another equivalent definition.
>>
>> Well that simplifies things.  
>
> When it is proven that set Q has the exactly same elements as set R
> then this proves that the definition of set Q is equivalent to the
> definition of set R.

Why do you keep repeating this?  If you are saying that your definition
of halting that is equivalent to the usual one, you need to post a
correction in some of the places where you previously stated that false
is the correct result for a finite computation.

If your most recent cut-and-paste mantra does not mean that you are now
using a definition that is equivalent to the proper one, then your error
still stands, having told me that:

(a) Halts(Confound_Halts, Confound_Halts) returns false, and
(b) the input to Halts is finite.

(by which you meant the input represents a finite computation).

Are you not correcting this silly mistake?

-- 
Ben.

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


#31675 — Re: Infinite recursion detection criteria: (equivalent definitions)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-20 17:17 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<wfOdnZAxyNB0z-L9nZ2dnUU7-RPNnZ2d@giganews.com>
In reply to#31668
On 4/20/2021 5:03 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
> <cut>
>>>>>>> The only problem is that false is the wrong answer for a finite
>>>>>>> computation.
>>>>>>
>>>>>> This must be over your head:
>>>>>> When set Q has the same members as set R then we can know that the
>>>>>> definition of set Q is equivalent to the definition of set R.
>>>>>
>>>>> So you don't dispute any of the facts.
>>>>
>>>> That fact has finally been made moot.
>>>>
>>>> I can transform one definition into another equivalent definition.
>>>
>>> Well that simplifies things.
>>
>> When it is proven that set Q has the exactly same elements as set R
>> then this proves that the definition of set Q is equivalent to the
>> definition of set R.
> 
> Why do you keep repeating this?  

To avoid intentionally deceptive "confusion" I require my respondents to 
acknowledge the validity of one point before moving on to the next 
point. We can keep going through this same point an infinite number of 
times.



-- 
Copyright 2021 Pete Olcott

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

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


#31710 — Re: Infinite recursion detection criteria: (equivalent definitions)

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

> On 4/20/2021 5:03 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
>> <cut>
>>>>>>>> The only problem is that false is the wrong answer for a finite
>>>>>>>> computation.
>>>>>>>
>>>>>>> This must be over your head:
>>>>>>> When set Q has the same members as set R then we can know that the
>>>>>>> definition of set Q is equivalent to the definition of set R.
>>>>>>
>>>>>> So you don't dispute any of the facts.
>>>>>
>>>>> That fact has finally been made moot.
>>>>>
>>>>> I can transform one definition into another equivalent definition.
>>>>
>>>> Well that simplifies things.
>>>
>>> When it is proven that set Q has the exactly same elements as set R
>>> then this proves that the definition of set Q is equivalent to the
>>> definition of set R.
>>
>> Why do you keep repeating this?  
>
> To avoid intentionally deceptive "confusion" I require my respondents
> to acknowledge the validity of one point before moving on to the next
> point. We can keep going through this same point an infinite number of
> times.

I see -- it's a ruse to avoid facing the facts.  Until you tell me
otherwise, the facts are that you have "refined halting" so that false
is the "correct" result for a finite computation:

(a) Halts(Confound_Halts, Confound_Halts) returns false, and
(b) the input to Halts is finite.

This is so silly I really thought you were trying to find a way to
retract it.  Oh, well, the silliness stands.

-- 
Ben.

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


#31720 — Re: Infinite recursion detection criteria: (equivalent definitions)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-20 21:50 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<k4idnRNQCqqZDuL9nZ2dnUU7-KvNnZ2d@giganews.com>
In reply to#31710
On 4/20/2021 8:15 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/20/2021 5:03 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
>>> <cut>
>>>>>>>>> The only problem is that false is the wrong answer for a finite
>>>>>>>>> computation.
>>>>>>>>
>>>>>>>> This must be over your head:
>>>>>>>> When set Q has the same members as set R then we can know that the
>>>>>>>> definition of set Q is equivalent to the definition of set R.
>>>>>>>
>>>>>>> So you don't dispute any of the facts.
>>>>>>
>>>>>> That fact has finally been made moot.
>>>>>>
>>>>>> I can transform one definition into another equivalent definition.
>>>>>
>>>>> Well that simplifies things.
>>>>
>>>> When it is proven that set Q has the exactly same elements as set R
>>>> then this proves that the definition of set Q is equivalent to the
>>>> definition of set R.
>>>
>>> Why do you keep repeating this?
>>
>> To avoid intentionally deceptive "confusion" I require my respondents
>> to acknowledge the validity of one point before moving on to the next
>> point. We can keep going through this same point an infinite number of
>> times.
> 
> I see -- it's a ruse to avoid facing the facts.  Until you tell me
> otherwise, the facts are that you have "refined halting" so that false
> is the "correct" result for a finite computation:

Computations that only halted because the halt decider correctly decided 
that their simulation must be aborted to prevent their otherwise 
infinite execution define the exact same set of elements as the set of 
non-halting computations.



-- 
Copyright 2021 Pete Olcott

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

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


#31726 — Re: Infinite recursion detection criteria: (equivalent definitions)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-21 04:15 +0100
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<8735vkuy4j.fsf@bsb.me.uk>
In reply to#31720
olcott <NoOne@NoWhere.com> writes:

> On 4/20/2021 8:15 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/20/2021 5:03 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
>>>> <cut>
>>>>>>>>>> The only problem is that false is the wrong answer for a finite
>>>>>>>>>> computation.
>>>>>>>>>
>>>>>>>>> This must be over your head:
>>>>>>>>> When set Q has the same members as set R then we can know that the
>>>>>>>>> definition of set Q is equivalent to the definition of set R.
>>>>>>>>
>>>>>>>> So you don't dispute any of the facts.
>>>>>>>
>>>>>>> That fact has finally been made moot.
>>>>>>>
>>>>>>> I can transform one definition into another equivalent definition.
>>>>>>
>>>>>> Well that simplifies things.
>>>>>
>>>>> When it is proven that set Q has the exactly same elements as set R
>>>>> then this proves that the definition of set Q is equivalent to the
>>>>> definition of set R.
>>>>
>>>> Why do you keep repeating this?
>>>
>>> To avoid intentionally deceptive "confusion" I require my respondents
>>> to acknowledge the validity of one point before moving on to the next
>>> point. We can keep going through this same point an infinite number of
>>> times.
>>
>> I see -- it's a ruse to avoid facing the facts.  Until you tell me
>> otherwise, the facts are that you have "refined halting" so that false
>> is the "correct" result for a finite computation:

You cut what you told me last year:

(a) Halts(Confound_Halts, Confound_Halts) returns false, and
(b) the input to Halts is finite.

Are you embarrassed by that now?  If not, you should take every
opportunity to see this brave new concept published.  Don't cut it!

> Computations that only halted because the halt decider correctly
> decided that their simulation must be aborted to prevent their
> otherwise infinite execution define the exact same set of elements as
> the set of non-halting computations.

According to you, the computation Confound_Halts(Confound_Halts) is
finite.  Are you still defending the silly notion that false is the
correct result from Halts for a finite computation?

The "reason" why a finite computation is finite is not a mathematical
concept.  Finite computations don't halt for a "reason".  They are
simply composed of a finite sequence of configurations.  A halt decider
should return true for each and every one of them.

-- 
Ben.

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


#31728 — Re: Infinite recursion detection criteria: (equivalent definitions)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-20 22:20 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<d8CdnWZ2XalvBOL9nZ2dnUU78T3NnZ2d@giganews.com>
In reply to#31726
On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/20/2021 8:15 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/20/2021 5:03 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
>>>>> <cut>
>>>>>>>>>>> The only problem is that false is the wrong answer for a finite
>>>>>>>>>>> computation.
>>>>>>>>>>
>>>>>>>>>> This must be over your head:
>>>>>>>>>> When set Q has the same members as set R then we can know that the
>>>>>>>>>> definition of set Q is equivalent to the definition of set R.
>>>>>>>>>
>>>>>>>>> So you don't dispute any of the facts.
>>>>>>>>
>>>>>>>> That fact has finally been made moot.
>>>>>>>>
>>>>>>>> I can transform one definition into another equivalent definition.
>>>>>>>
>>>>>>> Well that simplifies things.
>>>>>>
>>>>>> When it is proven that set Q has the exactly same elements as set R
>>>>>> then this proves that the definition of set Q is equivalent to the
>>>>>> definition of set R.
>>>>>
>>>>> Why do you keep repeating this?
>>>>
>>>> To avoid intentionally deceptive "confusion" I require my respondents
>>>> to acknowledge the validity of one point before moving on to the next
>>>> point. We can keep going through this same point an infinite number of
>>>> times.
>>>
>>> I see -- it's a ruse to avoid facing the facts.  Until you tell me
>>> otherwise, the facts are that you have "refined halting" so that false
>>> is the "correct" result for a finite computation:
> 
> You cut what you told me last year:
> 
> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
> (b) the input to Halts is finite.
> 
> Are you embarrassed by that now?  If not, you should take every
> opportunity to see this brave new concept published.  Don't cut it!

Halts() answers this question:
Will the input halt on its own without having its simulation aborted?

It turns out that this criteria picks out the exact same set of elements 
as the set of non-halting computations.

-- 
Copyright 2021 Pete Olcott

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

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


#31748 — Re: Infinite recursion detection criteria: (equivalent definitions)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-21 15:05 +0100
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<87a6prwx58.fsf@bsb.me.uk>
In reply to#31728
olcott <NoOne@NoWhere.com> writes:

> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/20/2021 8:15 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/20/2021 5:03 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
>>>>>> <cut>
>>>>>>>>>>>> The only problem is that false is the wrong answer for a finite
>>>>>>>>>>>> computation.
>>>>>>>>>>>
>>>>>>>>>>> This must be over your head:
>>>>>>>>>>> When set Q has the same members as set R then we can know that the
>>>>>>>>>>> definition of set Q is equivalent to the definition of set R.
>>>>>>>>>>
>>>>>>>>>> So you don't dispute any of the facts.
>>>>>>>>>
>>>>>>>>> That fact has finally been made moot.
>>>>>>>>>
>>>>>>>>> I can transform one definition into another equivalent definition.
>>>>>>>>
>>>>>>>> Well that simplifies things.
>>>>>>>
>>>>>>> When it is proven that set Q has the exactly same elements as set R
>>>>>>> then this proves that the definition of set Q is equivalent to the
>>>>>>> definition of set R.
>>>>>>
>>>>>> Why do you keep repeating this?
>>>>>
>>>>> To avoid intentionally deceptive "confusion" I require my respondents
>>>>> to acknowledge the validity of one point before moving on to the next
>>>>> point. We can keep going through this same point an infinite number of
>>>>> times.
>>>>
>>>> I see -- it's a ruse to avoid facing the facts.  Until you tell me
>>>> otherwise, the facts are that you have "refined halting" so that false
>>>> is the "correct" result for a finite computation:
>>
>> You cut what you told me last year:
>>
>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>> (b) the input to Halts is finite.
>>
>> Are you embarrassed by that now?  If not, you should take every
>> opportunity to see this brave new concept published.  Don't cut it!
>
> Halts() answers this question:
> Will the input halt on its own without having its simulation aborted?

Halts should answer the question: do the parameters passed represent a
finite (AKA halting) computation.  Since you've stated that Halts
returns the wrong answer for that question, you need to find a question
it answers correctly that looks less obviously wrong which you can
present as picking out the same set of computations.

This is linguistic endeavour, not a mathematical one.  I don't think
you've managed to pull the wool over anyone's eyes yet, so this part of
the plan appears to be failing.

Halting and non-halting can be defined with no ambiguity using
mathematics.  After all, a TM is a mathematical object -- a state
transition function.  Unfortunately, you don't have access to that level
of precision, but you would not want to use it even if you could.

> It turns out that this criteria picks out the exact same set of
> elements as the set of non-halting computations.

There's an interesting twist that I keep pointing out.  If you really
could detect those computations (and only those) that would not halt
were they properly simulated you'd have a halt decider.  And we know
that that is impossible.

But picking out those that halt because they include an embedded
quasi-simulator that opts not to continue simulating, catches an
entirely different set of computations.  And having Halts return false
of them is just admitting that have to give the wrong answer since they
clearly halt on their own.  The fact that the embedded quasi-simulator
is called Halts, and it attempting to determine non-halting behaviour
makes no difference.  A computation that halts, for whatever reason, is
finite an should be reported as such.

You've tied yourself up in knots given TMs action, agency and intent and
then wrapped that up in subjunctive clauses in such a messy way that you
appear to have fooled yourself.

I am almost tempted to suggest you do try to write these things
formally, but a fear that would be just too painful to watch.  Can you
even specify, rigorously, what it means for a TM computation to halt?

-- 
Ben.

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


#31753 — Re: Infinite recursion detection criteria: (equivalent definitions)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-21 09:35 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<-ZOdnQ28aJOppR39nZ2dnUU7-YPNnZ2d@giganews.com>
In reply to#31748
On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/20/2021 8:15 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/20/2021 5:03 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
>>>>>>> <cut>
>>>>>>>>>>>>> The only problem is that false is the wrong answer for a finite
>>>>>>>>>>>>> computation.
>>>>>>>>>>>>
>>>>>>>>>>>> This must be over your head:
>>>>>>>>>>>> When set Q has the same members as set R then we can know that the
>>>>>>>>>>>> definition of set Q is equivalent to the definition of set R.
>>>>>>>>>>>
>>>>>>>>>>> So you don't dispute any of the facts.
>>>>>>>>>>
>>>>>>>>>> That fact has finally been made moot.
>>>>>>>>>>
>>>>>>>>>> I can transform one definition into another equivalent definition.
>>>>>>>>>
>>>>>>>>> Well that simplifies things.
>>>>>>>>
>>>>>>>> When it is proven that set Q has the exactly same elements as set R
>>>>>>>> then this proves that the definition of set Q is equivalent to the
>>>>>>>> definition of set R.
>>>>>>>
>>>>>>> Why do you keep repeating this?
>>>>>>
>>>>>> To avoid intentionally deceptive "confusion" I require my respondents
>>>>>> to acknowledge the validity of one point before moving on to the next
>>>>>> point. We can keep going through this same point an infinite number of
>>>>>> times.
>>>>>
>>>>> I see -- it's a ruse to avoid facing the facts.  Until you tell me
>>>>> otherwise, the facts are that you have "refined halting" so that false
>>>>> is the "correct" result for a finite computation:
>>>
>>> You cut what you told me last year:
>>>
>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>> (b) the input to Halts is finite.
>>>
>>> Are you embarrassed by that now?  If not, you should take every
>>> opportunity to see this brave new concept published.  Don't cut it!
>>
>> Halts() answers this question:
>> Will the input halt on its own without having its simulation aborted?
> 
> Halts should answer the question: do the parameters passed represent a
> finite (AKA halting) computation. 

That is an equivalent question because it defines a set with the same 
members. Does the input halt on its input? is incorrect criteria for a 
halt decider based on simulating its input.

> Since you've stated that Halts
> returns the wrong answer for that question, you need to find a question
> it answers correctly that looks less obviously wrong which you can
> present as picking out the same set of computations.

Will the input halt on its own without having its simulation aborted?
Does correct discriminate between halting and non-halting elements as 
you have proved that you already know:

On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
 > A computation that would not halt if its simulation were not
 > halted is indeed a non-halting computation.

> This is linguistic endeavour, not a mathematical one.  I don't think
> you've managed to pull the wool over anyone's eyes yet, so this part of
> the plan appears to be failing.
> 
> Halting and non-halting can be defined with no ambiguity using
> mathematics.  After all, a TM is a mathematical object -- a state
> transition function.  Unfortunately, you don't have access to that level
> of precision, but you would not want to use it even if you could.
> 
>> It turns out that this criteria picks out the exact same set of
>> elements as the set of non-halting computations.
> 
> There's an interesting twist that I keep pointing out.  If you really
> could detect those computations (and only those) that would not halt
> were they properly simulated you'd have a halt decider.  And we know
> that that is impossible.

You and I both know that a halt decider based on simulating its input 
must abort the simulation of inputs that would otherwise not halt or it 
fails to be a decider.

That you now acknowledge that a halt decider based on simulation could 
work is an admission of your prior scam.

> But picking out those that halt because they include an embedded
> quasi-simulator that opts not to continue simulating, catches an
> entirely different set of computations.  And having Halts return false
> of them is just admitting that have to give the wrong answer since they

This criterion measure does divide all inputs into halting and not 
halting and you know it so please quit lying.

Will the input halt on its own without having its simulation aborted?

On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
 > A computation that would not halt if its simulation were not
 > halted is indeed a non-halting computation.

It is obvious to me that you are lying. My insight on Monday was that 
two different selection criteria define the same set of elements proving 
these these two different selection critieria are equivalent.

-- 
Copyright 2021 Pete Olcott

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

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


#31755 — Re: Infinite recursion detection criteria: (equivalent definitions)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-04-21 11:03 -0400
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<b9XfI.101423$nn2.6825@fx48.iad>
In reply to#31753
On 4/21/21 10:35 AM, olcott wrote:
> On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/20/2021 8:15 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/20/2021 5:03 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/20/2021 1:27 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/20/2021 6:00 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote:
>>>>>>>> <cut>
>>>>>>>>>>>>>> The only problem is that false is the wrong answer for a
>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This must be over your head:
>>>>>>>>>>>>> When set Q has the same members as set R then we can know
>>>>>>>>>>>>> that the
>>>>>>>>>>>>> definition of set Q is equivalent to the definition of set R.
>>>>>>>>>>>>
>>>>>>>>>>>> So you don't dispute any of the facts.
>>>>>>>>>>>
>>>>>>>>>>> That fact has finally been made moot.
>>>>>>>>>>>
>>>>>>>>>>> I can transform one definition into another equivalent
>>>>>>>>>>> definition.
>>>>>>>>>>
>>>>>>>>>> Well that simplifies things.
>>>>>>>>>
>>>>>>>>> When it is proven that set Q has the exactly same elements as
>>>>>>>>> set R
>>>>>>>>> then this proves that the definition of set Q is equivalent to the
>>>>>>>>> definition of set R.
>>>>>>>>
>>>>>>>> Why do you keep repeating this?
>>>>>>>
>>>>>>> To avoid intentionally deceptive "confusion" I require my
>>>>>>> respondents
>>>>>>> to acknowledge the validity of one point before moving on to the
>>>>>>> next
>>>>>>> point. We can keep going through this same point an infinite
>>>>>>> number of
>>>>>>> times.
>>>>>>
>>>>>> I see -- it's a ruse to avoid facing the facts.  Until you tell me
>>>>>> otherwise, the facts are that you have "refined halting" so that
>>>>>> false
>>>>>> is the "correct" result for a finite computation:
>>>>
>>>> You cut what you told me last year:
>>>>
>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>> (b) the input to Halts is finite.
>>>>
>>>> Are you embarrassed by that now?  If not, you should take every
>>>> opportunity to see this brave new concept published.  Don't cut it!
>>>
>>> Halts() answers this question:
>>> Will the input halt on its own without having its simulation aborted?
>>
>> Halts should answer the question: do the parameters passed represent a
>> finite (AKA halting) computation. 
> 
> That is an equivalent question because it defines a set with the same
> members. Does the input halt on its input? is incorrect criteria for a
> halt decider based on simulating its input.
> 

You say it a bit awkward, but why is the Question "Would the machine
represented by the input given to Halts, Halt or be non-Halting, when
given the input represented by the other part of the input to Halts?" be
invalid. That is exactly the question we want answered?

It isn't 'the input' it is 'the Turing Machine Represented by the Input'
that is the key item in question

>> Since you've stated that Halts
>> returns the wrong answer for that question, you need to find a question
>> it answers correctly that looks less obviously wrong which you can
>> present as picking out the same set of computations.
> 
> Will the input halt on its own without having its simulation aborted?
> Does correct discriminate between halting and non-halting elements as
> you have proved that you already know:
> 
> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>> A computation that would not halt if its simulation were not
>> halted is indeed a non-halting computation.
> 
>> This is linguistic endeavour, not a mathematical one.  I don't think
>> you've managed to pull the wool over anyone's eyes yet, so this part of
>> the plan appears to be failing.
>>
>> Halting and non-halting can be defined with no ambiguity using
>> mathematics.  After all, a TM is a mathematical object -- a state
>> transition function.  Unfortunately, you don't have access to that level
>> of precision, but you would not want to use it even if you could.
>>
>>> It turns out that this criteria picks out the exact same set of
>>> elements as the set of non-halting computations.
>>
>> There's an interesting twist that I keep pointing out.  If you really
>> could detect those computations (and only those) that would not halt
>> were they properly simulated you'd have a halt decider.  And we know
>> that that is impossible.
> 
> You and I both know that a halt decider based on simulating its input
> must abort the simulation of inputs that would otherwise not halt or it
> fails to be a decider.
> 
> That you now acknowledge that a halt decider based on simulation could
> work is an admission of your prior scam.
> 
>> But picking out those that halt because they include an embedded
>> quasi-simulator that opts not to continue simulating, catches an
>> entirely different set of computations.  And having Halts return false
>> of them is just admitting that have to give the wrong answer since they
> 
> This criterion measure does divide all inputs into halting and not
> halting and you know it so please quit lying.
> 
> Will the input halt on its own without having its simulation aborted?
> 
> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>> A computation that would not halt if its simulation were not
>> halted is indeed a non-halting computation.
> 
> It is obvious to me that you are lying. My insight on Monday was that
> two different selection criteria define the same set of elements proving
> these these two different selection critieria are equivalent.
> 

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


#31793 — Re: Infinite recursion detection criteria: (equivalent definitions)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-21 23:32 +0100
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<8735vjuv3u.fsf@bsb.me.uk>
In reply to#31753
olcott <NoOne@NoWhere.com> writes:

> On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:

>>>> You cut what you told me last year:
>>>>
>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>> (b) the input to Halts is finite.
>>>>
>>>> Are you embarrassed by that now?  If not, you should take every
>>>> opportunity to see this brave new concept published.  Don't cut it!
>>>
>>> Halts() answers this question:
>>> Will the input halt on its own without having its simulation aborted?
>>
>> Halts should answer the question: do the parameters passed represent a
>> finite (AKA halting) computation. 
>
> That is an equivalent question because it defines a set with the same
> members.

It can't be an equivalent question because you told me it classifies at
least one input differently.

>> Since you've stated that Halts
>> returns the wrong answer for that question, you need to find a question
>> it answers correctly that looks less obviously wrong which you can
>> present as picking out the same set of computations.
>
> Will the input halt on its own without having its simulation aborted?

Wrong question.  It's not even a clear question, but that's deliberate.
Halting is a simple criterion, so you don't want to use it.

> Does correct discriminate between halting and non-halting elements as
> you have proved that you already know:

Whilst it's not clear what you mean by it, you have told me that it
declares some finite computations to be non-halting.  That means you
know it not right as the sane people in the world interpret the term.

> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>> A computation that would not halt if its simulation were not
>> halted is indeed a non-halting computation.
>> But a computation that
>> would not halt and one that is halted are different computations.

(I've completed the quote for you.  Remember to include both parts since
the discussion back then was about your two computation ruse.)

<cut>
>> There's an interesting twist that I keep pointing out.  If you really
>> could detect those computations (and only those) that would not halt
>> were they properly simulated you'd have a halt decider.  And we know
>> that that is impossible.
>
> You and I both know that a halt decider based on simulating its input
> must abort the simulation of inputs that would otherwise not halt or
> it fails to be a decider.

You may think you know that, but I don't.  I know that any TM, based on
any method whatsoever, fails to be a halt decider.  One based crudely on
partial simulation fails particularly spectacularly, but then that's
what we'd expect -- you chose that design.

> That you now acknowledge that a halt decider based on simulation could
> work is an admission of your prior scam.

Babbling.  No TM is a halt decider.  The basis is irrelevant.  You know
I would never intentionally say otherwise, so whilst I may have made a
mistake, or you may have misunderstood, it's dishonest of you to pretend
that I agree with your nonsense.

And if I said otherwise, you know I was wrong.  If you /think/ I said
otherwise, you know you misunderstood.  And no one is going to take your
accusation of a scam seriously.

>> But picking out those that halt because they include an embedded
>> quasi-simulator that opts not to continue simulating, catches an
>> entirely different set of computations.  And having Halts return false
>> of them is just admitting that have to give the wrong answer since they
>
> This criterion measure does divide all inputs into halting and not
> halting and you know it so please quit lying.

It does not divide computations correctly into halting and non-halting.
You declare the wrong result to be "correct" because you know your plan
gets the answer wrong.

> Will the input halt on its own without having its simulation aborted?

Nonsense.  The question, as you know, is whether the computation is
finite or not.  It's that simple.  No agency or conditional statements.
No "on its own".  No fudging "its simulation" when you mean "the partial
simulation embedded within the computation".  It is finite or not?

> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>> A computation that would not halt if its simulation were not
>> halted is indeed a non-halting computation.
>> But a computation that
>> would not halt and one that is halted are different computations.

> It is obvious to me that you are lying.

You keep bringing this up, so you must still be trying the two
computations ruse: the wrong answer for one is declared to be right
because of what the other computation "would do".  Have you found a way
to pull this trick without having to comment out a line get the
non-halting computation?  That was ridiculously crude, even for you.

-- 
Ben.

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


#31795 — Re: Infinite recursion detection criteria: (equivalent definitions)

Fromolcott <NoOne@NoWhere.com>
Date2021-04-21 17:39 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<MsydnUD4gMMzNB39nZ2dnUU7-I3NnZ2d@giganews.com>
In reply to#31793
On 4/21/2021 5:32 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
> 
>>>>> You cut what you told me last year:
>>>>>
>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>>> (b) the input to Halts is finite.
>>>>>
>>>>> Are you embarrassed by that now?  If not, you should take every
>>>>> opportunity to see this brave new concept published.  Don't cut it!
>>>>
>>>> Halts() answers this question:
>>>> Will the input halt on its own without having its simulation aborted?
>>>
>>> Halts should answer the question: do the parameters passed represent a
>>> finite (AKA halting) computation.
>>
>> That is an equivalent question because it defines a set with the same
>> members.
> 
> It can't be an equivalent question because you told me it classifies at
> least one input differently.
> 

It does not classify at least one input differently.

>>> Since you've stated that Halts
>>> returns the wrong answer for that question, you need to find a question
>>> it answers correctly that looks less obviously wrong which you can
>>> present as picking out the same set of computations.
>>
>> Will the input halt on its own without having its simulation aborted?
> 
> Wrong question.  It's not even a clear question, but that's deliberate.
> Halting is a simple criterion, so you don't want to use it.
Either set theory is over your head totally failing to understand that 
two entirely different set definitions can be known to be equivalent as 
long as the specify the same set of elements or you are a liar.

Because you keep dodging acknowledging the correctness of this:

When it is proven that set Q has the exactly same elements as set R then 
this proves that the definition of set Q is equivalent to the definition 
of set R.

I am going with you are a liar.


-- 
Copyright 2021 Pete Olcott

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

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


#31811 — Re: Infinite recursion detection criteria: (equivalent definitions)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-22 01:37 +0100
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)
Message-ID<878s5btaro.fsf@bsb.me.uk>
In reply to#31795
olcott <NoOne@NoWhere.com> writes:

> On 4/21/2021 5:32 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
>>
>>>>>> You cut what you told me last year:
>>>>>>
>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>>>> (b) the input to Halts is finite.
>>>>>>
>>>>>> Are you embarrassed by that now?  If not, you should take every
>>>>>> opportunity to see this brave new concept published.  Don't cut it!
>>>>>
>>>>> Halts() answers this question:
>>>>> Will the input halt on its own without having its simulation aborted?
>>>>
>>>> Halts should answer the question: do the parameters passed represent a
>>>> finite (AKA halting) computation.
>>>
>>> That is an equivalent question because it defines a set with the same
>>> members.
>>
>> It can't be an equivalent question because you told me it classifies at
>> least one input differently.
>
> It does not classify at least one input differently.

If the questions are effectively the same, then Halts does not answer
either of them correctly because you told me (and I could verify it from
the code sketch you posted at the time) that Halts returns false for a
finite computation.

But I don't think that's what's going on.  You have not re-phrased the
clear and simple definition of what Halts should return into this fuzzy
and vague form simply for Halts to be wrong about it!  No, in the
specific case cited above, you intend false to be the correct answer to
your new question, where it is obviously the wrong answer for mine.

> I am going with you are a liar.

I'm going with something else altogether.

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-04-21 19:42 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<dvKdndd8-JT_Wx39nZ2dnUU7-TmdnZ2d@giganews.com>
In reply to#31811
On 4/21/2021 7:37 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/21/2021 5:32 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
>>>
>>>>>>> You cut what you told me last year:
>>>>>>>
>>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>>>>> (b) the input to Halts is finite.
>>>>>>>
>>>>>>> Are you embarrassed by that now?  If not, you should take every
>>>>>>> opportunity to see this brave new concept published.  Don't cut it!
>>>>>>
>>>>>> Halts() answers this question:
>>>>>> Will the input halt on its own without having its simulation aborted?
>>>>>
>>>>> Halts should answer the question: do the parameters passed represent a
>>>>> finite (AKA halting) computation.
>>>>
>>>> That is an equivalent question because it defines a set with the same
>>>> members.
>>>
>>> It can't be an equivalent question because you told me it classifies at
>>> least one input differently.
>>
>> It does not classify at least one input differently.
> 
> If the questions are effectively the same, then Halts does not answer
> either of them correctly because you told me (and I could verify it from
> the code sketch you posted at the time) that Halts returns false for a
> finite computation.
> 
> But I don't think that's what's going on.  You have not re-phrased the
> clear and simple definition of what Halts should return into this fuzzy
> and vague form simply for Halts to be wrong about it!  No, in the
> specific case cited above, you intend false to be the correct answer to
> your new question, where it is obviously the wrong answer for mine.

Every finite string representing an element of the set of non halting 
computations would halt if its simulation was stopped.

We cannot accurately say that the set of non halting computations is the 
empty set.

∴ Every finite string that only halts because its simulation was stopped 
is an element of the set of non-halting computations.


-- 
Copyright 2021 Pete Olcott

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

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


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

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

> On 4/21/2021 7:37 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/21/2021 5:32 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
>>>>
>>>>>>>> You cut what you told me last year:
>>>>>>>>
>>>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>>>>>> (b) the input to Halts is finite.
>>>>>>>>
>>>>>>>> Are you embarrassed by that now?  If not, you should take every
>>>>>>>> opportunity to see this brave new concept published.  Don't cut it!
>>>>>>>
>>>>>>> Halts() answers this question:
>>>>>>> Will the input halt on its own without having its simulation aborted?
>>>>>>
>>>>>> Halts should answer the question: do the parameters passed represent a
>>>>>> finite (AKA halting) computation.
>>>>>
>>>>> That is an equivalent question because it defines a set with the same
>>>>> members.
>>>>
>>>> It can't be an equivalent question because you told me it classifies at
>>>> least one input differently.
>>>
>>> It does not classify at least one input differently.
>>
>> If the questions are effectively the same, then Halts does not answer
>> either of them correctly because you told me (and I could verify it from
>> the code sketch you posted at the time) that Halts returns false for a
>> finite computation.
>>
>> But I don't think that's what's going on.  You have not re-phrased the
>> clear and simple definition of what Halts should return into this fuzzy
>> and vague form simply for Halts to be wrong about it!  No, in the
>> specific case cited above, you intend false to be the correct answer to
>> your new question, where it is obviously the wrong answer for mine.
>
> Every finite string representing an element of the set of non halting
> computations would halt if its simulation was stopped.

No.  Read your words carefully.  What is the subject of "would halt"?
It is "Every finite string ...", but strings don't halt.  You mean
something else, but since you are attempting a "proof by linguistic
gymnastics" it would be bad for me to guess.  What is it that "would
halt" since it can't be a string.

You night be trying to refer to the computation the string encodes, but
that is wrong too.  The computation represented by the string would not
halt if its simulation were stopped.  In fact the computation
represented by the string is not even running when the simulation is
running.  If you insist on using words like "would" (and I think you
need them to pull off the trick) then you must take the consequences.

You could unambiguously state static, timeless and unconditional
properties of computations and strings, but that would probably be too
clear for your purposes.  Mathematicians would use formal symbols:

     UTM(<[M], [I]>) = ⊥   iff   M(I) = ⊥

for example (the simulation of a computation is non-halting if and only
if the computation itself is non-halting).

> We cannot accurately say that the set of non halting computations is
> the empty set.

  ∃ M, I  s.t. M(I) = ⊥

> ∴ Every finite string that only halts because its simulation was
> stopped is an element of the set of non-halting computations.

There it is!  The magic "its" has switched meaning.  At least I think
it's now supposed to refer to the quasi-simulation embedded within a
computation that uses one of your broken partial halt deciders.

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-04-21 21:22 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<6-WdnQ8Dq6ZvQB39nZ2dnUU7-anNnZ2d@giganews.com>
In reply to#31817
On 4/21/2021 8:46 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/21/2021 7:37 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/21/2021 5:32 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
>>>>>
>>>>>>>>> You cut what you told me last year:
>>>>>>>>>
>>>>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>>>>>>> (b) the input to Halts is finite.
>>>>>>>>>
>>>>>>>>> Are you embarrassed by that now?  If not, you should take every
>>>>>>>>> opportunity to see this brave new concept published.  Don't cut it!
>>>>>>>>
>>>>>>>> Halts() answers this question:
>>>>>>>> Will the input halt on its own without having its simulation aborted?
>>>>>>>
>>>>>>> Halts should answer the question: do the parameters passed represent a
>>>>>>> finite (AKA halting) computation.
>>>>>>
>>>>>> That is an equivalent question because it defines a set with the same
>>>>>> members.
>>>>>
>>>>> It can't be an equivalent question because you told me it classifies at
>>>>> least one input differently.
>>>>
>>>> It does not classify at least one input differently.
>>>
>>> If the questions are effectively the same, then Halts does not answer
>>> either of them correctly because you told me (and I could verify it from
>>> the code sketch you posted at the time) that Halts returns false for a
>>> finite computation.
>>>
>>> But I don't think that's what's going on.  You have not re-phrased the
>>> clear and simple definition of what Halts should return into this fuzzy
>>> and vague form simply for Halts to be wrong about it!  No, in the
>>> specific case cited above, you intend false to be the correct answer to
>>> your new question, where it is obviously the wrong answer for mine.
>>
>> Every finite string representing an element of the set of non halting
>> computations would halt if its simulation was stopped.
> 
> No.  Read your words carefully.  What is the subject of "would halt"?
> It is "Every finite string ...", but strings don't halt.  You mean
> something else, but since you are attempting a "proof by linguistic
> gymnastics" it would be bad for me to guess.  What is it that "would
> halt" since it can't be a string.
> 
> You night be trying to refer to the computation the string encodes, but
> that is wrong too.  The computation represented by the string would not
> halt if its simulation were stopped.  In fact the computation
> represented by the string is not even running when the simulation is
> running.  If you insist on using words like "would" (and I think you
> need them to pull off the trick) then you must take the consequences.
> 
> You could unambiguously state static, timeless and unconditional
> properties of computations and strings, but that would probably be too
> clear for your purposes.  Mathematicians would use formal symbols:
> 
>       UTM(<[M], [I]>) = ⊥   iff   M(I) = ⊥
> 
> for example (the simulation of a computation is non-halting if and only
> if the computation itself is non-halting).
> 
>> We cannot accurately say that the set of non halting computations is
>> the empty set.
> 
>    ∃ M, I  s.t. M(I) = ⊥      ∃ M, I  | M(I) = ⊥

> 
>> ∴ Every finite string that only halts because its simulation was
>> stopped is an element of the set of non-halting computations.
> 
> There it is!  The magic "its" has switched meaning.  At least I think
> it's now supposed to refer to the quasi-simulation embedded within a
> computation that uses one of your broken partial halt deciders.

Hypothesizing that machine F always correctly decides that its input 
pair (X,Y) of Turing machine descriptions must have its simulation by F 
stopped to prevent infinite simulation of input pair (X,Y).
F(X,Y) = ⊤ // meaning not stopped

∀(X,Y) ∈ Turing_Machine_Descriptions | F(X,Y) iff Halts(X,Y);




-- 
Copyright 2021 Pete Olcott

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

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-22 13:15 +0100
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<8735visefz.fsf@bsb.me.uk>
In reply to#31818
olcott <NoOne@NoWhere.com> writes:

> On 4/21/2021 8:46 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/21/2021 7:37 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/21/2021 5:32 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
>>>>>>
>>>>>>>>>> You cut what you told me last year:
>>>>>>>>>>
>>>>>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>>>>>>>> (b) the input to Halts is finite.
>>>>>>>>>>
>>>>>>>>>> Are you embarrassed by that now?  If not, you should take every
>>>>>>>>>> opportunity to see this brave new concept published.  Don't cut it!
>>>>>>>>>
>>>>>>>>> Halts() answers this question:
>>>>>>>>> Will the input halt on its own without having its simulation aborted?
>>>>>>>>
>>>>>>>> Halts should answer the question: do the parameters passed represent a
>>>>>>>> finite (AKA halting) computation.
>>>>>>>
>>>>>>> That is an equivalent question because it defines a set with the same
>>>>>>> members.
>>>>>>
>>>>>> It can't be an equivalent question because you told me it classifies at
>>>>>> least one input differently.
>>>>>
>>>>> It does not classify at least one input differently.
>>>>
>>>> If the questions are effectively the same, then Halts does not answer
>>>> either of them correctly because you told me (and I could verify it from
>>>> the code sketch you posted at the time) that Halts returns false for a
>>>> finite computation.
>>>>
>>>> But I don't think that's what's going on.  You have not re-phrased the
>>>> clear and simple definition of what Halts should return into this fuzzy
>>>> and vague form simply for Halts to be wrong about it!  No, in the
>>>> specific case cited above, you intend false to be the correct answer to
>>>> your new question, where it is obviously the wrong answer for mine.
>>>
>>> Every finite string representing an element of the set of non halting
>>> computations would halt if its simulation was stopped.
>>
>> No.  Read your words carefully.  What is the subject of "would halt"?
>> It is "Every finite string ...", but strings don't halt.  You mean
>> something else, but since you are attempting a "proof by linguistic
>> gymnastics" it would be bad for me to guess.  What is it that "would
>> halt" since it can't be a string.
>>
>> You night be trying to refer to the computation the string encodes, but
>> that is wrong too.  The computation represented by the string would not
>> halt if its simulation were stopped.  In fact the computation
>> represented by the string is not even running when the simulation is
>> running.  If you insist on using words like "would" (and I think you
>> need them to pull off the trick) then you must take the consequences.
>>
>> You could unambiguously state static, timeless and unconditional
>> properties of computations and strings, but that would probably be too
>> clear for your purposes.  Mathematicians would use formal symbols:
>>
>>       UTM(<[M], [I]>) = ⊥   iff   M(I) = ⊥
>>
>> for example (the simulation of a computation is non-halting if and only
>> if the computation itself is non-halting).
>>
>>> We cannot accurately say that the set of non halting computations is
>>> the empty set.
>>
>>    ∃ M, I  s.t. M(I) = ⊥      ∃ M, I  | M(I) = ⊥
>
>>
>>> ∴ Every finite string that only halts because its simulation was
>>> stopped is an element of the set of non-halting computations.
>>
>> There it is!  The magic "its" has switched meaning.  At least I think
>> it's now supposed to refer to the quasi-simulation embedded within a
>> computation that uses one of your broken partial halt deciders.
>
> Hypothesizing that machine F always correctly decides that its input
> pair (X,Y) of Turing machine descriptions must have its simulation by
> F stopped to prevent infinite simulation of input pair (X,Y).

This sentence no verb (no main verb).  "Hypothesising that ... of the
input pair (X, Y) is pointless"?  "Hypothesising that ... of the input
pair (X, Y) is fun -- you should try it"?  What are trying to say about
this hypothesising?  Maybe you just meant "I am hypothesising that
... of the input pair (X, Y)".

And then you need to fix the (deliberate?) ambiguity about what "its
simulation by F" refers to.  Does one of X or Y contain an embedded
simulation by F?

And then what the singular "its" doing there when there are two encoded
machines?  Is F simulating them "in parallel"?  Is it simulating one
after the other?  Only one?  (Yes, I can guess, but being clear would
mean I don't have to guess.)

> F(X,Y) = ⊤ // meaning not stopped

Strange use of top.  Is F(X,Y) = ⊤ even when F(X, Y) diverges?  F(X,Y)
usually means the result of the TM F with input <X,Y>.  Top is not a
usual result for any TM.

> ∀(X,Y) ∈ Turing_Machine_Descriptions | F(X,Y) iff Halts(X,Y);

(X, Y) is a pair; it can't be a member of that set (unless the set is
badly named).  I think you mean ∀ X,Y ∈ Turing_Machine_Descriptions...

So the notation F(X,Y) is also being used as a predicate?  OK, that's
not the best way to use a name that denotes a TM.  For one thing you
need to say when it's true/false.  Presumably that's whether it accepts
or rejects?

F appears to be unbound in this sentence.  That's ok in informal writing
like this but that does not mean it's clear.  Is this is definition of F
(with the possibility that no such F exists)?  Unlikely.  And it's also
unlikely that you meant this is true for all F.  Most likely, you
intended your opening sentence to define an F and this one was supposed
to say more about it.

And what is Halts?  It's the name you've been using for a TM that we
have never seen fully realised.  The same questions apply to this name
as to F.  Maybe you are defining what Halts should do?

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-04-22 09:33 -0500
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<readncmm2oqnFBz9nZ2dnUU7-UXNnZ2d@giganews.com>
In reply to#31837
On 4/22/2021 7:15 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 4/21/2021 8:46 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/21/2021 7:37 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/21/2021 5:32 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/21/2021 9:05 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/20/2021 10:15 PM, Ben Bacarisse wrote:
>>>>>>>
>>>>>>>>>>> You cut what you told me last year:
>>>>>>>>>>>
>>>>>>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and
>>>>>>>>>>> (b) the input to Halts is finite.
>>>>>>>>>>>
>>>>>>>>>>> Are you embarrassed by that now?  If not, you should take every
>>>>>>>>>>> opportunity to see this brave new concept published.  Don't cut it!
>>>>>>>>>>
>>>>>>>>>> Halts() answers this question:
>>>>>>>>>> Will the input halt on its own without having its simulation aborted?
>>>>>>>>>
>>>>>>>>> Halts should answer the question: do the parameters passed represent a
>>>>>>>>> finite (AKA halting) computation.
>>>>>>>>
>>>>>>>> That is an equivalent question because it defines a set with the same
>>>>>>>> members.
>>>>>>>
>>>>>>> It can't be an equivalent question because you told me it classifies at
>>>>>>> least one input differently.
>>>>>>
>>>>>> It does not classify at least one input differently.
>>>>>
>>>>> If the questions are effectively the same, then Halts does not answer
>>>>> either of them correctly because you told me (and I could verify it from
>>>>> the code sketch you posted at the time) that Halts returns false for a
>>>>> finite computation.
>>>>>
>>>>> But I don't think that's what's going on.  You have not re-phrased the
>>>>> clear and simple definition of what Halts should return into this fuzzy
>>>>> and vague form simply for Halts to be wrong about it!  No, in the
>>>>> specific case cited above, you intend false to be the correct answer to
>>>>> your new question, where it is obviously the wrong answer for mine.
>>>>
>>>> Every finite string representing an element of the set of non halting
>>>> computations would halt if its simulation was stopped.
>>>
>>> No.  Read your words carefully.  What is the subject of "would halt"?
>>> It is "Every finite string ...", but strings don't halt.  You mean
>>> something else, but since you are attempting a "proof by linguistic
>>> gymnastics" it would be bad for me to guess.  What is it that "would
>>> halt" since it can't be a string.
>>>
>>> You night be trying to refer to the computation the string encodes, but
>>> that is wrong too.  The computation represented by the string would not
>>> halt if its simulation were stopped.  In fact the computation
>>> represented by the string is not even running when the simulation is
>>> running.  If you insist on using words like "would" (and I think you
>>> need them to pull off the trick) then you must take the consequences.
>>>
>>> You could unambiguously state static, timeless and unconditional
>>> properties of computations and strings, but that would probably be too
>>> clear for your purposes.  Mathematicians would use formal symbols:
>>>
>>>        UTM(<[M], [I]>) = ⊥   iff   M(I) = ⊥
>>>
>>> for example (the simulation of a computation is non-halting if and only
>>> if the computation itself is non-halting).
>>>
>>>> We cannot accurately say that the set of non halting computations is
>>>> the empty set.
>>>
>>>     ∃ M, I  s.t. M(I) = ⊥      ∃ M, I  | M(I) = ⊥
>>
>>>
>>>> ∴ Every finite string that only halts because its simulation was
>>>> stopped is an element of the set of non-halting computations.
>>>
>>> There it is!  The magic "its" has switched meaning.  At least I think
>>> it's now supposed to refer to the quasi-simulation embedded within a
>>> computation that uses one of your broken partial halt deciders.
>>
>> Hypothesizing that machine F always correctly decides that its input
>> pair (X,Y) of Turing machine descriptions must have its simulation by
>> F stopped to prevent infinite simulation of input pair (X,Y).
> 
> This sentence no verb (no main verb).  "Hypothesising that ... of the

The Turing Machine Halting Problem
We begin with some problems that have some historical significance
and that at the same time give us a starting point for developing later
results. The best-known of these is the Turing machine halting problem.
Simply stated, the problem is: given the description of a Turing machine M
and an input w, does M, when started in the initial configuration q0w,
perform a computation that eventually halts? Using an abbreviated way
of talking about the problem, we ask whether M applied to w, or simply
(M, w), halts or does not halt. The domain of this problem is to be taken as
the set of all Turing machines and all w; that is, we are looking for a 
single
Turing machine that, given the description of an arbitrary M and w, will
predict whether or not the computation of M applied to w will halt.

Proof: We assume the contrary, namely that there exists an algorithm,
and consequently some Turing machine H, that solves the halting problem.
The input to H will be the description (encoded in some form) of M, say
WM, as well as the input w. The requirement is then that, given any (WM, w),
the Turing machine H will halt with either a yes or no answer. We achieve
this by asking that H halt in one oftwo corresponding final states, say, 
qy or
qn. The situation can be visualized by a block diagram like Figure 12.1. The
intent of this diagram is to indicate that, if M is started in state qo 
with input
(WM, w), it will eventually halt in state qy or qn. 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



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.
(g) At the point where F infallibly detects the infinite execution of 
its input pair F decides to stop simulating its input.


>> ∀(X,Y) ∈ Turing_Machine_Descriptions | F(X,Y) iff Halts(X,Y);
> 
> (X, Y) is a pair; it can't be a member of that set (unless the set is
> badly named).  

I think you mean ∀ X,Y ∈ Turing_Machine_Descriptions...

∀(X) ∈ Turing_Machine_Descriptions,
∀(Y) ∈ Turing_Machine_Descriptions
F(X,Y) iff Halts(X,Y); // The mathemtical definition of Halts

> So the notation F(X,Y) is also being used as a predicate?  OK, that's
> not the best way to use a name that denotes a TM.  For one thing you
> need to say when it's true/false.  Presumably that's whether it accepts
> or rejects?
> 

When-so-ever F decides to abort the simulation of its input this means 
not halting.

When-so-ever F does not decide to abort the simulation of its input this 
means halting.

The set of (X,Y) pairs where X is a Turing machine description and Y is 
a  finite string that would not halt on their input is the same set that 
must have their simulation aborted by a halt decider that bases its 
halting decision on simulating its input.

> F appears to be unbound in this sentence.  That's ok in informal writing
> like this but that does not mean it's clear.  Is this is definition of F
> (with the possibility that no such F exists)?  Unlikely.  And it's also
> unlikely that you meant this is true for all F.  Most likely, you
> intended your opening sentence to define an F and this one was supposed
> to say more about it.
> 
> And what is Halts?  It's the name you've been using for a TM that we
> have never seen fully realised.  The same questions apply to this name
> as to F.  Maybe you are defining what Halts should do?
> 

∀(X) ∈ Turing_Machine_Descriptions,
∀(Y) ∈ Turing_Machine_Descriptions
Not_Halting(X,Y) = Simulation_Must_Be_Aborted(X,Y)



Every finite string representing an element of the set of non halting 
computations would halt if its simulation was stopped.

We cannot accurately say that the set of non halting computations is the 
empty set.

∴ Every finite string that only halts because its simulation was stopped 
is an element of the set of non-halting computations.



-- 
Copyright 2021 Pete Olcott

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

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-23 00:41 +0100
SubjectRe: Infinite recursion detection criteria: (equivalent definitions)(easier?)
Message-ID<87fszhrioe.fsf@bsb.me.uk>
In reply to#31845
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.  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.

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.

-- 
Ben.

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


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

Back to top | Article view | comp.theory


csiph-web