Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #35756 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-07-05 11:28 -0500 |
| Last post | 2021-07-08 20:37 -0700 |
| Articles | 20 on this page of 334 — 17 participants |
Back to article view | Back to comp.theory
How do we know that H(P,P)==0 is correct? olcott <NoOne@NoWhere.com> - 2021-07-05 11:28 -0500
Re: How do we know that H(P,P)==0 is correct? Richard Damon <Richard@Damon-Family.org> - 2021-07-05 13:06 -0400
Re: How do we know that H(P,P)==0 is correct? olcott <NoOne@NoWhere.com> - 2021-07-05 12:17 -0500
Re: How do we know that H(P,P)==0 is correct? Richard Damon <Richard@Damon-Family.org> - 2021-07-05 13:54 -0400
Re: How do we know that H(P,P)==0 is correct? olcott <NoOne@NoWhere.com> - 2021-07-05 14:30 -0500
Re: How do we know that H(P,P)==0 is correct? Richard Damon <Richard@Damon-Family.org> - 2021-07-05 15:54 -0400
Re: How do we know that H(P,P)==0 is correct? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-05 22:34 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-05 16:40 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Richard Damon <Richard@Damon-Family.org> - 2021-07-05 17:48 -0400
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-05 17:41 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Richard Damon <Richard@Damon-Family.org> - 2021-07-05 19:14 -0400
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-06 00:15 +0100
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) olcott <NoOne@NoWhere.com> - 2021-07-05 19:04 -0500
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Richard Damon <Richard@Damon-Family.org> - 2021-07-05 20:45 -0400
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) olcott <NoOne@NoWhere.com> - 2021-07-05 20:01 -0500
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Richard Damon <Richard@Damon-Family.org> - 2021-07-05 21:22 -0400
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) olcott <NoOne@NoWhere.com> - 2021-07-05 21:37 -0500
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Richard Damon <Richard@Damon-Family.org> - 2021-07-06 06:38 -0400
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 04:14 -0700
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-06 03:33 +0100
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) olcott <NoOne@NoWhere.com> - 2021-07-05 22:06 -0500
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-06 13:39 +0100
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) olcott <NoOne@NoWhere.com> - 2021-07-06 10:59 -0500
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 02:55 +0100
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Richard Damon <Richard@Damon-Family.org> - 2021-07-06 22:29 -0400
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) olcott <NoOne@NoWhere.com> - 2021-07-06 11:33 -0500
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 11:19 -0700
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) olcott <NoOne@NoWhere.com> - 2021-07-06 13:28 -0500
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 11:32 -0700
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) olcott <NoOne@NoWhere.com> - 2021-07-06 14:16 -0500
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Richard Damon <Richard@Damon-Family.org> - 2021-07-06 22:32 -0400
Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 02:56 +0100
Re: How do we know that H(P,P)==0 is correct? (V2) olcott <NoOne@NoWhere.com> - 2021-07-06 21:00 -0500
Re: How do we know that H(P,P)==0 is correct? (V2) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 16:32 +0100
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 11:24 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) wij <wyniijj@gmail.com> - 2021-07-07 10:53 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 13:10 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) wij <wyniijj@gmail.com> - 2021-07-07 11:59 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 14:51 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) wij <wyniijj@gmail.com> - 2021-07-07 13:47 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 14:35 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 16:49 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 20:18 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 20:24 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 21:45 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 21:04 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 22:45 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 22:03 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-08 06:56 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) [ independent v dependent variables ] olcott <NoOne@NoWhere.com> - 2021-07-08 07:46 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) [ independent v dependent variables ] Richard Damon <Richard@Damon-Family.org> - 2021-07-08 23:39 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) [ independent v dependent variables ] olcott <NoOne@NoWhere.com> - 2021-07-08 22:54 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) [ independent v dependent variables ] André G. Isaak <agisaak@gm.invalid> - 2021-07-08 22:15 -0600
Re: How do we know that H(P,P)==0 is correct? (V3) [ independent v dependent variables ] olcott <NoOne@NoWhere.com> - 2021-07-08 23:26 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) [ independent v dependent variables ] André G. Isaak <agisaak@gm.invalid> - 2021-07-08 22:44 -0600
Re: How do we know that H(P,P)==0 is correct? (V3) [ independent v dependent variables ] olcott <NoOne@NoWhere.com> - 2021-07-08 23:53 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 22:10 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 22:53 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-08 06:58 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-08 07:58 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-08 06:12 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-08 08:35 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-08 07:12 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-08 09:18 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-08 07:41 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-08 17:07 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) olcott <NoOne@NoWhere.com> - 2021-07-08 11:24 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-08 09:55 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-08 23:52 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) olcott <NoOne@NoWhere.com> - 2021-07-08 20:07 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-09 02:48 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-08 21:21 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-08 21:36 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-09 12:30 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 05:56 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 08:59 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Real Troll <real.troll@trolls.com> - 2021-07-09 17:59 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 20:32 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 19:28 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-09 18:06 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 12:47 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-09 20:16 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 14:24 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 12:33 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-09 22:08 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 16:13 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-10 12:40 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] olcott <NoOne@NoWhere.com> - 2021-07-10 08:54 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-10 15:30 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] olcott <NoOne@NoWhere.com> - 2021-07-10 10:00 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-10 16:15 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] olcott <NoOne@NoWhere.com> - 2021-07-10 10:21 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-10 16:25 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-10 08:30 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-10 16:33 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-10 08:34 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-10 08:45 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] olcott <NoOne@NoWhere.com> - 2021-07-10 11:08 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-10 17:34 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ]( You and I ) olcott <NoOne@NoWhere.com> - 2021-07-10 11:42 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ]( You and I ) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-10 10:54 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ]( You and I ) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-10 11:23 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ]( You and I ) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-10 11:41 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ]( You and I ) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-10 13:15 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-10 08:24 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-07-10 15:19 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] gazelle@shell.xmission.com (Kenny McCormack) - 2021-07-11 00:29 +0000
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] olcott <NoOne@NoWhere.com> - 2021-07-10 19:57 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-07-10 20:33 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] olcott <NoOne@NoWhere.com> - 2021-07-10 22:59 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-09 23:10 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 17:41 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 12:28 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 10:50 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-09 22:59 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 17:29 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-10 00:23 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 18:31 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-10 01:13 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 19:33 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-11 01:57 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-10 20:00 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-11 03:08 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-10 22:13 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-07-10 23:13 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Mr Flibble <flibble@reddwarf.jmc> - 2021-07-11 07:14 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-11 00:27 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-11 01:07 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-11 01:39 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-07-11 01:42 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-11 09:16 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-11 09:16 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-11 11:10 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-11 09:30 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-11 20:04 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ]( Flibble agrees ) olcott <NoOne@NoWhere.com> - 2021-07-11 14:47 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-11 22:35 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-12 09:13 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-12 09:20 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Theperfect Parrotsstore <theperfectparrotsstore@gmail.com> - 2021-07-12 08:23 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-12 12:35 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-12 12:39 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-12 17:18 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-12 18:00 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 08:41 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 07:57 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 09:42 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] wij <wyniijj@gmail.com> - 2021-07-13 07:54 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 10:02 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-13 22:23 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-14 15:52 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Andy Walker <anw@cuboid.co.uk> - 2021-07-14 22:09 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-14 16:47 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-14 21:03 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-14 20:57 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-14 22:12 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-14 21:57 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-07-15 01:44 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-15 09:17 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-15 21:04 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-15 16:31 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-15 15:08 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-15 15:18 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-15 16:13 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-07-15 16:54 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-15 19:42 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-17 07:25 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-16 01:17 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-15 19:52 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-16 03:09 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) olcott <NoOne@NoWhere.com> - 2021-07-15 22:03 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-17 01:43 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-16 19:07 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-16 19:29 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-16 19:54 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) olcott <NoOne@NoWhere.com> - 2021-07-16 22:34 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-16 21:11 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) olcott <NoOne@NoWhere.com> - 2021-07-16 21:48 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Richard Damon <Richard@Damon-Family.org> - 2021-07-17 07:44 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-18 02:27 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-17 18:43 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-18 03:45 +0100
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-17 23:05 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) olcott <NoOne@NoWhere.com> - 2021-07-19 10:11 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ](and Flibble) Richard Damon <Richard@Damon-Family.org> - 2021-07-16 22:52 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-15 13:12 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-16 22:39 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 09:08 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 10:33 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 09:36 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 10:43 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 10:11 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 17:21 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 16:44 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 17:55 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 17:08 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 18:50 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 18:20 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 19:32 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 19:02 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 20:11 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 19:42 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 20:52 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 20:07 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 21:14 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-13 20:30 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-13 21:42 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-13 22:29 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-14 15:53 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-14 15:01 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-14 16:39 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-14 21:06 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-13 23:13 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-14 10:07 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-14 21:35 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-12 21:20 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-12 21:15 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Richard Damon <Richard@Damon-Family.org> - 2021-07-12 21:10 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-07-11 06:54 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ suspended not halted ] olcott <NoOne@NoWhere.com> - 2021-07-11 09:14 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-09 20:39 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 20:08 -0700
The (binary decision) tree of the knowledge of Good and Evil olcott <NoOne@NoWhere.com> - 2021-07-09 22:30 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 20:42 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 22:18 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-09 21:46 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 23:01 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-09 22:28 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 23:45 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-09 23:24 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 22:32 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 22:39 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 23:01 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-10 09:25 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] André G. Isaak <agisaak@gm.invalid> - 2021-07-10 09:12 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ type mismatch error ] olcott <NoOne@NoWhere.com> - 2021-07-10 10:32 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ type mismatch error ] André G. Isaak <agisaak@gm.invalid> - 2021-07-10 09:48 -0600
Re: How do we know that H(P,P)==0 is correct? (V4) [ type mismatch error ] olcott <NoOne@NoWhere.com> - 2021-07-10 11:19 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 21:51 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 21:59 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 21:01 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-09 21:17 -0700
Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] olcott <NoOne@NoWhere.com> - 2021-07-09 23:24 -0500
Re: How do we know that H(P,P)==0 is correct? (V4) Richard Damon <Richard@Damon-Family.org> - 2021-07-08 23:50 -0400
Re: How do we know that H(P,P)==0 is correct? (V4) Richard Damon <Richard@Damon-Family.org> - 2021-07-08 23:43 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-08 23:40 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 20:17 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 20:31 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 21:51 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 21:07 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 22:51 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 22:04 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-08 07:02 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) [ global halt decider ] olcott <NoOne@NoWhere.com> - 2021-07-08 08:29 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) [ global halt decider ] Richard Damon <Richard@Damon-Family.org> - 2021-07-09 00:05 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) [ global halt decider ] olcott <NoOne@NoWhere.com> - 2021-07-08 23:27 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) [ global halt decider ] Richard Damon <Richard@Damon-Family.org> - 2021-07-09 05:53 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) [ global halt decider ] olcott <NoOne@NoWhere.com> - 2021-07-09 09:02 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 20:59 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-05 23:15 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-06 13:07 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 08:27 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) wij <wyniijj@gmail.com> - 2021-07-06 07:42 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 10:26 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Richard Damon <Richard@Damon-Family.org> - 2021-07-06 22:02 -0400
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 02:56 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Richard Damon <Richard@Damon-Family.org> - 2021-07-06 21:59 -0400
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Mr Flibble <flibble@reddwarf.jmc> - 2021-07-06 21:18 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 15:41 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Mr Flibble <flibble@reddwarf.jmc> - 2021-07-06 23:18 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 16:13 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 18:38 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 18:44 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 16:53 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 18:56 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 17:46 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 19:50 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 17:56 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 20:18 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 18:37 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 20:43 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 18:55 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-06 19:06 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Richard Damon <Richard@Damon-Family.org> - 2021-07-06 22:19 -0400
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 08:01 -0400
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-06 20:47 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 03:23 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-07-06 22:19 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 00:55 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-07 09:35 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-07 09:29 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 16:31 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-07 10:53 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 17:33 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-07 12:06 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 20:28 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-07 14:54 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 10:19 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 12:21 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Andy Walker <anw@cuboid.co.uk> - 2021-07-07 19:05 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-07 13:30 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) André G. Isaak <agisaak@gm.invalid> - 2021-07-07 14:28 -0600
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-07 16:44 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-07-07 15:50 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) olcott <NoOne@NoWhere.com> - 2021-07-07 18:09 -0500
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 20:22 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Richard Damon <Richard@Damon-Family.org> - 2021-07-06 22:08 -0400
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-07-06 14:31 -0700
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Richard Damon <Richard@Damon-Family.org> - 2021-07-06 22:35 -0400
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-07-07 11:46 +0100
Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 04:50 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 09:47 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 20:26 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 17:34 -0700
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 20:15 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 22:00 -0400
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 21:08 -0500
Re: How do we know that H(P,P)==0 is correct? (V3) Richard Damon <Richard@Damon-Family.org> - 2021-07-07 22:51 -0400
Re: How do we know that H(P,P)==0 is correct? Bonita Montero <Bonita.Montero@gmail.com> - 2021-07-07 14:18 +0200
Re: How do we know that H(P,P)==0 is correct? (V3) olcott <NoOne@NoWhere.com> - 2021-07-07 14:39 -0500
Re: How do we know that H(P,P)==0 is correct? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-07-07 14:52 -0700
Re: How do we know that H(P,P)==0 is correct? olcott <NoOne@NoWhere.com> - 2021-07-07 17:05 -0500
Re: How do we know that H(P,P)==0 is correct? wij <wyniijj@gmail.com> - 2021-07-07 15:41 -0700
Re: How do we know that H(P,P)==0 is correct? [ proof ] olcott <NoOne@NoWhere.com> - 2021-07-07 18:04 -0500
Re: How do we know that H(P,P)==0 is correct? [ proof ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 16:19 -0700
Re: How do we know that H(P,P)==0 is correct? [ proof ] olcott <NoOne@NoWhere.com> - 2021-07-07 18:34 -0500
Re: How do we know that H(P,P)==0 is correct? [ proof ] "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-07-07 17:03 -0700
Re: How do we know that H(P,P)==0 is correct? [ proof ] olcott <NoOne@NoWhere.com> - 2021-07-07 19:14 -0500
Re: How do we know that H(P,P)==0 is correct? [ proof ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 17:19 -0700
Re: How do we know that H(P,P)==0 is correct? [ proof ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-07 17:26 -0700
Re: How do we know that H(P,P)==0 is correct? [ proof ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-07-08 02:41 -0700
Re: How do we know that H(P,P)==0 is correct? [ proof ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-08 02:50 -0700
Re: How do we know that H(P,P)==0 is correct? [ proof ] Jeff Barnett <jbb@notatt.com> - 2021-07-08 14:08 -0600
Re: How do we know that H(P,P)==0 is correct? [ proof ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-07-08 20:37 -0700
Page 8 of 17 — ← Prev page 1 … 6 7 [8] 9 10 … 17 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-12 12:35 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <4YmdnX88fbj64HH9nZ2dnUU7-UnNnZ2d@giganews.com> |
| In reply to | #36183 |
On 7/12/2021 10:20 AM, André G. Isaak wrote: > On 2021-07-12 08:13, olcott wrote: >> On 7/11/2021 11:35 PM, Richard Damon wrote: >>> On 7/11/21 9:30 AM, olcott wrote: >>> >>>> According to this criteria P(P) specifies a computation that never >>>> halts. >>> >>> Which since even YOU have shown that if H does give the answer of >>> Non-Halting, that P(P) will halt when run as an independent machine, so >>> the logic must be wrong. >>> >> >> It does not halt it has its execution suspended. >> If its execution was not suspended it would never halt. > > The SIMULATION OF ITS INPUT is suspended. But when we ask whether P(P) > halts we're not asking about the input to P(P). We're asking about P(P) > proper. *You must be dumber than a box of rocks* Do you know know that when any function call (of infinite recursion) from the first to the trillionth is aborted that even though this infinite recursion stops running IT IS STILL INFINITE RECURSION !!! > P(P) simulates its input, suspends the simulation of its input, and then > HALTS. There isn't anything which can suspend the execution of the > outermost P when it is run as an independent machine since it isn't > being simulated. > > André > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-07-12 12:39 -0600 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <sci289$97u$1@dont-email.me> |
| In reply to | #36188 |
On 2021-07-12 11:35, olcott wrote: > On 7/12/2021 10:20 AM, André G. Isaak wrote: >> On 2021-07-12 08:13, olcott wrote: >>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>> On 7/11/21 9:30 AM, olcott wrote: >>>> >>>>> According to this criteria P(P) specifies a computation that never >>>>> halts. >>>> >>>> Which since even YOU have shown that if H does give the answer of >>>> Non-Halting, that P(P) will halt when run as an independent machine, so >>>> the logic must be wrong. >>>> >>> >>> It does not halt it has its execution suspended. >>> If its execution was not suspended it would never halt. >> >> The SIMULATION OF ITS INPUT is suspended. But when we ask whether P(P) >> halts we're not asking about the input to P(P). We're asking about >> P(P) proper. > > *You must be dumber than a box of rocks* > Do you know know that when any function call (of infinite recursion) > from the first to the trillionth is aborted that even though this > infinite recursion stops running IT IS STILL INFINITE RECURSION !!! By that "reasoning" (using the term very loosely), when you run H(Infinite_Recursion) and H suspends Infinite_recursion, it not only entails that Infinite_Recursion (the thing being simulating) is non-halting, but also that H (the simulator) is non-halting. Remember that a decider, *by definition* must be guaranteed to halt and return a result. When you run P(P) as an independent computation, the H inside P behaves identically to the *top-level* H in H(P, P). Both are the thing doing the simulating, not the thing being simulated. André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-12 17:18 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <CbqdnTORaaoqInH9nZ2dnUU7-InNnZ2d@giganews.com> |
| In reply to | #36189 |
On 7/12/2021 1:39 PM, André G. Isaak wrote: > On 2021-07-12 11:35, olcott wrote: >> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>> On 2021-07-12 08:13, olcott wrote: >>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>> >>>>>> According to this criteria P(P) specifies a computation that never >>>>>> halts. >>>>> >>>>> Which since even YOU have shown that if H does give the answer of >>>>> Non-Halting, that P(P) will halt when run as an independent >>>>> machine, so >>>>> the logic must be wrong. >>>>> >>>> >>>> It does not halt it has its execution suspended. >>>> If its execution was not suspended it would never halt. >>> >>> The SIMULATION OF ITS INPUT is suspended. But when we ask whether >>> P(P) halts we're not asking about the input to P(P). We're asking >>> about P(P) proper. >> >> *You must be dumber than a box of rocks* >> Do you know know that when any function call (of infinite recursion) >> from the first to the trillionth is aborted that even though this >> infinite recursion stops running IT IS STILL INFINITE RECURSION !!! > > > By that "reasoning" (using the term very loosely), when you run > H(Infinite_Recursion) and H suspends Infinite_recursion, it not only > entails that Infinite_Recursion (the thing being simulating) is > non-halting, but also that H (the simulator) is non-halting. > I prove that this is not true by actually showing the steps of infinite recursion being decided: https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation > Remember that a decider, *by definition* must be guaranteed to halt and > return a result. > I am not dumber than a box of rocks so I already know this. > When you run P(P) as an independent computation, the H inside P behaves > identically to the *top-level* H in H(P, P). Both are the thing doing > the simulating, not the thing being simulated. > > André > When you do not segregate the behavior being measured from the measure of the behavior pathological self-reference(Olcott 2004) occurs. Even after thousands of years people still do not understand that self contradictory expressions of language do not map to a Boolean value only because they are erroneous. Tarski has a whole undefinability of truth theorem that is entirely based on the impossibility of proving that a lie is true. How dumb is that? http://www.liarparadox.org/Tarski_247_248.pdf http://www.liarparadox.org/Tarski_275_276.pdf The Tarski theorem is exactly as if the 1931 Gödel incompleteness theorem has been translated to HOL having an actual provability predicate: x ∉ Pr if and only if p In the above expression x ∉ Pr is intended to mean: Provable(x) -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-07-12 18:00 -0600 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <scil3i$tqr$1@dont-email.me> |
| In reply to | #36203 |
On 2021-07-12 16:18, olcott wrote: > On 7/12/2021 1:39 PM, André G. Isaak wrote: >> On 2021-07-12 11:35, olcott wrote: >>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>> On 2021-07-12 08:13, olcott wrote: >>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>> >>>>>>> According to this criteria P(P) specifies a computation that >>>>>>> never halts. >>>>>> >>>>>> Which since even YOU have shown that if H does give the answer of >>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>> machine, so >>>>>> the logic must be wrong. >>>>>> >>>>> >>>>> It does not halt it has its execution suspended. >>>>> If its execution was not suspended it would never halt. >>>> >>>> The SIMULATION OF ITS INPUT is suspended. But when we ask whether >>>> P(P) halts we're not asking about the input to P(P). We're asking >>>> about P(P) proper. >>> >>> *You must be dumber than a box of rocks* >>> Do you know know that when any function call (of infinite recursion) >>> from the first to the trillionth is aborted that even though this >>> infinite recursion stops running IT IS STILL INFINITE RECURSION !!! >> >> >> By that "reasoning" (using the term very loosely), when you run >> H(Infinite_Recursion) and H suspends Infinite_recursion, it not only >> entails that Infinite_Recursion (the thing being simulating) is >> non-halting, but also that H (the simulator) is non-halting. >> > > I prove that this is not true by actually showing the steps of infinite > recursion being decided: > > https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation > > >> Remember that a decider, *by definition* must be guaranteed to halt >> and return a result. >> > > I am not dumber than a box of rocks so I already know this. You seem to be entirely missing my point. Compare the following: (1) When we run H(P, P), the topmost H is *not* being simulated. It starts simulating its input, and at some point it suspends that simulation. (2) When we run P(P), the H at the beginning of the topmost P is *not* being simulated. It starts simulating its input and at some point it suspends its simulation. In the first case, you conclude that the input to H is non-halting based on the fact that it has been suspended, but you acknowledge that H halts. In the second case, you conclude that the input the the H at the beginning of the topmost P is non-halting based on the fact that it has been suspended, but you somehow also conclude that the topmost P does not halt. How can you claim that the topmost H halts in (1), but that the topmost P doesn't halt in (2). These are identical in all respects. Either your argument that P(P) doesn't halt is invalid, or your reasoning also entails that H(P, P) does not halt (which would violate the claim that H is a decider). Which is it? André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-13 08:41 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <3sadnQAKPPuWBXD9nZ2dnUU7-aXNnZ2d@giganews.com> |
| In reply to | #36218 |
On 7/12/2021 7:00 PM, André G. Isaak wrote: > On 2021-07-12 16:18, olcott wrote: >> On 7/12/2021 1:39 PM, André G. Isaak wrote: >>> On 2021-07-12 11:35, olcott wrote: >>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>>> On 2021-07-12 08:13, olcott wrote: >>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>>> >>>>>>>> According to this criteria P(P) specifies a computation that >>>>>>>> never halts. >>>>>>> >>>>>>> Which since even YOU have shown that if H does give the answer of >>>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>>> machine, so >>>>>>> the logic must be wrong. >>>>>>> >>>>>> >>>>>> It does not halt it has its execution suspended. >>>>>> If its execution was not suspended it would never halt. >>>>> >>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask whether >>>>> P(P) halts we're not asking about the input to P(P). We're asking >>>>> about P(P) proper. >>>> >>>> *You must be dumber than a box of rocks* >>>> Do you know know that when any function call (of infinite recursion) >>>> from the first to the trillionth is aborted that even though this >>>> infinite recursion stops running IT IS STILL INFINITE RECURSION !!! >>> >>> >>> By that "reasoning" (using the term very loosely), when you run >>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not only >>> entails that Infinite_Recursion (the thing being simulating) is >>> non-halting, but also that H (the simulator) is non-halting. >>> >> >> I prove that this is not true by actually showing the steps of >> infinite recursion being decided: >> >> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation >> >> >>> Remember that a decider, *by definition* must be guaranteed to halt >>> and return a result. >>> >> >> I am not dumber than a box of rocks so I already know this. > > You seem to be entirely missing my point. > > Compare the following: > > (1) When we run H(P, P), the topmost H is *not* being simulated. It > starts simulating its input, and at some point it suspends that simulation. > The fact that it must suspend the simulation at one point because the simulation <is> infinite proves beyond all possible doubt that the halt decider was correct at that point. It does not matter what happens after that point. It does not matter what happens after that point. It does not matter what happens after that point. If you know that an animal is a cat by testing its DNA then you know that it is a cat even if this cat barks. > (2) When we run P(P), the H at the beginning of the topmost P is *not* > being simulated. It starts simulating its input and at some point it > suspends its simulation. > > In the first case, you conclude that the input to H is non-halting based > on the fact that it has been suspended, but you acknowledge that H halts. > This is where you <are> dumber than a box of rocks. This is where you <are> dumber than a box of rocks. This is where you <are> dumber than a box of rocks. It is not that H made some arbitrary decision to suspend its input and we are relying on this arbitrary decision. It is the logical necessity that unless H suspends its input the simulation of its input is necessarily infinite thus conclusively proving beyond all possible doubt that P(P) <is> a computation that never halts. > In the second case, you conclude that the input the the H at the > beginning of the topmost P is non-halting based on the fact that it has > been suspended, but you somehow also conclude that the topmost P does > not halt. > > How can you claim that the topmost H halts in (1), but that the topmost > P doesn't halt in (2). These are identical in all respects. Either your > argument that P(P) doesn't halt is invalid, or your reasoning also > entails that H(P, P) does not halt (which would violate the claim that H > is a decider). Which is it? > > André > When H can monitor all of the behavior of P(P) H immediately aborts P before ever returning any value to P. When P has sneaky behavior behind the back of H, H cannot immediately terminate P. Drug dealers can get away with bad things until the cops are watching. When the cops are watching the behavior of the drug dealer is aborted. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-07-13 07:57 -0600 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <sck644$82n$1@dont-email.me> |
| In reply to | #36237 |
On 2021-07-13 07:41, olcott wrote: > On 7/12/2021 7:00 PM, André G. Isaak wrote: >> On 2021-07-12 16:18, olcott wrote: >>> On 7/12/2021 1:39 PM, André G. Isaak wrote: >>>> On 2021-07-12 11:35, olcott wrote: >>>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>>>> On 2021-07-12 08:13, olcott wrote: >>>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>>>> >>>>>>>>> According to this criteria P(P) specifies a computation that >>>>>>>>> never halts. >>>>>>>> >>>>>>>> Which since even YOU have shown that if H does give the answer of >>>>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>>>> machine, so >>>>>>>> the logic must be wrong. >>>>>>>> >>>>>>> >>>>>>> It does not halt it has its execution suspended. >>>>>>> If its execution was not suspended it would never halt. >>>>>> >>>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask whether >>>>>> P(P) halts we're not asking about the input to P(P). We're asking >>>>>> about P(P) proper. >>>>> >>>>> *You must be dumber than a box of rocks* >>>>> Do you know know that when any function call (of infinite >>>>> recursion) from the first to the trillionth is aborted that even >>>>> though this infinite recursion stops running IT IS STILL INFINITE >>>>> RECURSION !!! >>>> >>>> >>>> By that "reasoning" (using the term very loosely), when you run >>>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not only >>>> entails that Infinite_Recursion (the thing being simulating) is >>>> non-halting, but also that H (the simulator) is non-halting. >>>> >>> >>> I prove that this is not true by actually showing the steps of >>> infinite recursion being decided: >>> >>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation >>> >>> >>>> Remember that a decider, *by definition* must be guaranteed to halt >>>> and return a result. >>>> >>> >>> I am not dumber than a box of rocks so I already know this. >> >> You seem to be entirely missing my point. >> >> Compare the following: >> >> (1) When we run H(P, P), the topmost H is *not* being simulated. It >> starts simulating its input, and at some point it suspends that >> simulation. >> > > The fact that it must suspend the simulation at one point because the > simulation <is> infinite proves beyond all possible doubt that the halt > decider was correct at that point. > > It does not matter what happens after that point. > It does not matter what happens after that point. > It does not matter what happens after that point. > > If you know that an animal is a cat by testing its DNA then you know > that it is a cat even if this cat barks. > >> (2) When we run P(P), the H at the beginning of the topmost P is *not* >> being simulated. It starts simulating its input and at some point it >> suspends its simulation. >> >> In the first case, you conclude that the input to H is non-halting >> based on the fact that it has been suspended, but you acknowledge that >> H halts. >> > > This is where you <are> dumber than a box of rocks. > This is where you <are> dumber than a box of rocks. > This is where you <are> dumber than a box of rocks. > > It is not that H made some arbitrary decision to suspend its input and > we are relying on this arbitrary decision. Nowhere above do I claim the decision is arbitrary, nor is that relevant to the point I am making. > It is the logical necessity that unless H suspends its input the > simulation of its input is necessarily infinite thus conclusively > proving beyond all possible doubt that P(P) <is> a computation that > never halts. > >> In the second case, you conclude that the input the the H at the >> beginning of the topmost P is non-halting based on the fact that it >> has been suspended, but you somehow also conclude that the topmost P >> does not halt. >> >> How can you claim that the topmost H halts in (1), but that the >> topmost P doesn't halt in (2). These are identical in all respects. >> Either your argument that P(P) doesn't halt is invalid, or your >> reasoning also entails that H(P, P) does not halt (which would violate >> the claim that H is a decider). Which is it? >> >> André >> > > When H can monitor all of the behavior of P(P) H immediately aborts P > before ever returning any value to P. When P has sneaky behavior behind > the back of H, H cannot immediately terminate P. Drug dealers can get > away with bad things until the cops are watching. When the cops are > watching the behavior of the drug dealer is aborted. You seem to be entirely ignoring my question. Do you claim that H(P, P) halts? If so, how can you claim that P(P), when run as an *independent* computation, does not halt given that it performs the exact same steps as H(P, P)? Both start simulating what you describe as an 'infinitely nested simulation' and both suspend that simulation at some point for identical reasons. André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-13 09:42 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <j5adnWfddJLxO3D9nZ2dnUU7-fvNnZ2d@giganews.com> |
| In reply to | #36240 |
On 7/13/2021 8:57 AM, André G. Isaak wrote: > On 2021-07-13 07:41, olcott wrote: >> On 7/12/2021 7:00 PM, André G. Isaak wrote: >>> On 2021-07-12 16:18, olcott wrote: >>>> On 7/12/2021 1:39 PM, André G. Isaak wrote: >>>>> On 2021-07-12 11:35, olcott wrote: >>>>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>>>>> On 2021-07-12 08:13, olcott wrote: >>>>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>>>>> >>>>>>>>>> According to this criteria P(P) specifies a computation that >>>>>>>>>> never halts. >>>>>>>>> >>>>>>>>> Which since even YOU have shown that if H does give the answer of >>>>>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>>>>> machine, so >>>>>>>>> the logic must be wrong. >>>>>>>>> >>>>>>>> >>>>>>>> It does not halt it has its execution suspended. >>>>>>>> If its execution was not suspended it would never halt. >>>>>>> >>>>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask whether >>>>>>> P(P) halts we're not asking about the input to P(P). We're asking >>>>>>> about P(P) proper. >>>>>> >>>>>> *You must be dumber than a box of rocks* >>>>>> Do you know know that when any function call (of infinite >>>>>> recursion) from the first to the trillionth is aborted that even >>>>>> though this infinite recursion stops running IT IS STILL INFINITE >>>>>> RECURSION !!! >>>>> >>>>> >>>>> By that "reasoning" (using the term very loosely), when you run >>>>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not >>>>> only entails that Infinite_Recursion (the thing being simulating) >>>>> is non-halting, but also that H (the simulator) is non-halting. >>>>> >>>> >>>> I prove that this is not true by actually showing the steps of >>>> infinite recursion being decided: >>>> >>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation >>>> >>>> >>>>> Remember that a decider, *by definition* must be guaranteed to halt >>>>> and return a result. >>>>> >>>> >>>> I am not dumber than a box of rocks so I already know this. >>> >>> You seem to be entirely missing my point. >>> >>> Compare the following: >>> >>> (1) When we run H(P, P), the topmost H is *not* being simulated. It >>> starts simulating its input, and at some point it suspends that >>> simulation. >>> >> >> The fact that it must suspend the simulation at one point because the >> simulation <is> infinite proves beyond all possible doubt that the >> halt decider was correct at that point. >> >> It does not matter what happens after that point. >> It does not matter what happens after that point. >> It does not matter what happens after that point. >> >> If you know that an animal is a cat by testing its DNA then you know >> that it is a cat even if this cat barks. >> >>> (2) When we run P(P), the H at the beginning of the topmost P is >>> *not* being simulated. It starts simulating its input and at some >>> point it suspends its simulation. >>> >>> In the first case, you conclude that the input to H is non-halting >>> based on the fact that it has been suspended, but you acknowledge >>> that H halts. >>> >> >> This is where you <are> dumber than a box of rocks. >> This is where you <are> dumber than a box of rocks. >> This is where you <are> dumber than a box of rocks. >> >> It is not that H made some arbitrary decision to suspend its input and >> we are relying on this arbitrary decision. > > Nowhere above do I claim the decision is arbitrary, nor is that relevant > to the point I am making. > >> It is the logical necessity that unless H suspends its input the >> simulation of its input is necessarily infinite thus conclusively >> proving beyond all possible doubt that P(P) <is> a computation that >> never halts. >> >>> In the second case, you conclude that the input the the H at the >>> beginning of the topmost P is non-halting based on the fact that it >>> has been suspended, but you somehow also conclude that the topmost P >>> does not halt. >>> >>> How can you claim that the topmost H halts in (1), but that the >>> topmost P doesn't halt in (2). These are identical in all respects. >>> Either your argument that P(P) doesn't halt is invalid, or your >>> reasoning also entails that H(P, P) does not halt (which would >>> violate the claim that H is a decider). Which is it? >>> >>> André >>> >> >> When H can monitor all of the behavior of P(P) H immediately aborts P >> before ever returning any value to P. When P has sneaky behavior >> behind the back of H, H cannot immediately terminate P. Drug dealers >> can get away with bad things until the cops are watching. When the >> cops are watching the behavior of the drug dealer is aborted. > > > You seem to be entirely ignoring my question. Do you claim that H(P, P) > halts? > I claim that H(P,P) always correctly decides that its input never halts. This remains true no matter what happens after H(P,P) is correctly decided. > If so, how can you claim that P(P), when run as an *independent* > computation, does not halt given that it performs the exact same steps When we test the DNA of a cat and find that it is definitely a cat and this cat later gives birth to purebred Chihuahua puppies we know for sure that it is definitely a cat. > as H(P, P)? Both start simulating what you describe as an 'infinitely > nested simulation' and both suspend that simulation at some point for > identical reasons. > > André > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | wij <wyniijj@gmail.com> |
|---|---|
| Date | 2021-07-13 07:54 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <2339c785-28df-4353-b071-697c926e68afn@googlegroups.com> |
| In reply to | #36245 |
On Tuesday, 13 July 2021 at 22:42:59 UTC+8, olcott wrote: > On 7/13/2021 8:57 AM, André G. Isaak wrote: > > On 2021-07-13 07:41, olcott wrote: > >> On 7/12/2021 7:00 PM, André G. Isaak wrote: > >>> On 2021-07-12 16:18, olcott wrote: > >>>> On 7/12/2021 1:39 PM, André G. Isaak wrote: > >>>>> On 2021-07-12 11:35, olcott wrote: > >>>>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: > >>>>>>> On 2021-07-12 08:13, olcott wrote: > >>>>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: > >>>>>>>>> On 7/11/21 9:30 AM, olcott wrote: > >>>>>>>>> > >>>>>>>>>> According to this criteria P(P) specifies a computation that > >>>>>>>>>> never halts. > >>>>>>>>> > >>>>>>>>> Which since even YOU have shown that if H does give the answer of > >>>>>>>>> Non-Halting, that P(P) will halt when run as an independent > >>>>>>>>> machine, so > >>>>>>>>> the logic must be wrong. > >>>>>>>>> > >>>>>>>> > >>>>>>>> It does not halt it has its execution suspended. > >>>>>>>> If its execution was not suspended it would never halt. > >>>>>>> > >>>>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask whether > >>>>>>> P(P) halts we're not asking about the input to P(P). We're asking > >>>>>>> about P(P) proper. > >>>>>> > >>>>>> *You must be dumber than a box of rocks* > >>>>>> Do you know know that when any function call (of infinite > >>>>>> recursion) from the first to the trillionth is aborted that even > >>>>>> though this infinite recursion stops running IT IS STILL INFINITE > >>>>>> RECURSION !!! > >>>>> > >>>>> > >>>>> By that "reasoning" (using the term very loosely), when you run > >>>>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not > >>>>> only entails that Infinite_Recursion (the thing being simulating) > >>>>> is non-halting, but also that H (the simulator) is non-halting. > >>>>> > >>>> > >>>> I prove that this is not true by actually showing the steps of > >>>> infinite recursion being decided: > >>>> > >>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation > >>>> > >>>> > >>>>> Remember that a decider, *by definition* must be guaranteed to halt > >>>>> and return a result. > >>>>> > >>>> > >>>> I am not dumber than a box of rocks so I already know this. > >>> > >>> You seem to be entirely missing my point. > >>> > >>> Compare the following: > >>> > >>> (1) When we run H(P, P), the topmost H is *not* being simulated. It > >>> starts simulating its input, and at some point it suspends that > >>> simulation. > >>> > >> > >> The fact that it must suspend the simulation at one point because the > >> simulation <is> infinite proves beyond all possible doubt that the > >> halt decider was correct at that point. > >> > >> It does not matter what happens after that point. > >> It does not matter what happens after that point. > >> It does not matter what happens after that point. > >> > >> If you know that an animal is a cat by testing its DNA then you know > >> that it is a cat even if this cat barks. > >> > >>> (2) When we run P(P), the H at the beginning of the topmost P is > >>> *not* being simulated. It starts simulating its input and at some > >>> point it suspends its simulation. > >>> > >>> In the first case, you conclude that the input to H is non-halting > >>> based on the fact that it has been suspended, but you acknowledge > >>> that H halts. > >>> > >> > >> This is where you <are> dumber than a box of rocks. > >> This is where you <are> dumber than a box of rocks. > >> This is where you <are> dumber than a box of rocks. > >> > >> It is not that H made some arbitrary decision to suspend its input and > >> we are relying on this arbitrary decision. > > > > Nowhere above do I claim the decision is arbitrary, nor is that relevant > > to the point I am making. > > > >> It is the logical necessity that unless H suspends its input the > >> simulation of its input is necessarily infinite thus conclusively > >> proving beyond all possible doubt that P(P) <is> a computation that > >> never halts. > >> > >>> In the second case, you conclude that the input the the H at the > >>> beginning of the topmost P is non-halting based on the fact that it > >>> has been suspended, but you somehow also conclude that the topmost P > >>> does not halt. > >>> > >>> How can you claim that the topmost H halts in (1), but that the > >>> topmost P doesn't halt in (2). These are identical in all respects. > >>> Either your argument that P(P) doesn't halt is invalid, or your > >>> reasoning also entails that H(P, P) does not halt (which would > >>> violate the claim that H is a decider). Which is it? > >>> > >>> André > >>> > >> > >> When H can monitor all of the behavior of P(P) H immediately aborts P > >> before ever returning any value to P. When P has sneaky behavior > >> behind the back of H, H cannot immediately terminate P. Drug dealers > >> can get away with bad things until the cops are watching. When the > >> cops are watching the behavior of the drug dealer is aborted. > > > > > > You seem to be entirely ignoring my question. Do you claim that H(P, P) > > halts? > > > I claim that H(P,P) always correctly decides that its input never halts. > This remains true no matter what happens after H(P,P) is correctly decided. According to GUA https://groups.google.com/g/comp.theory/c/65ZaXe9Sabk, H tries to decide the (dynamic) property of P that P can defy, thus, H is undecidable. Your H is a false teller. -- Copyright 2021 WIJ "If I can see further it is by standing on top of the tower of dwarfs."
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-13 10:02 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <0eudnTXpfb-MNnD9nZ2dnUU7-e-dnZ2d@giganews.com> |
| In reply to | #36246 |
On 7/13/2021 9:54 AM, wij wrote: > On Tuesday, 13 July 2021 at 22:42:59 UTC+8, olcott wrote: >> On 7/13/2021 8:57 AM, André G. Isaak wrote: >>> On 2021-07-13 07:41, olcott wrote: >>>> On 7/12/2021 7:00 PM, André G. Isaak wrote: >>>>> On 2021-07-12 16:18, olcott wrote: >>>>>> On 7/12/2021 1:39 PM, André G. Isaak wrote: >>>>>>> On 2021-07-12 11:35, olcott wrote: >>>>>>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>>>>>>> On 2021-07-12 08:13, olcott wrote: >>>>>>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>>>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>>>>>>> >>>>>>>>>>>> According to this criteria P(P) specifies a computation that >>>>>>>>>>>> never halts. >>>>>>>>>>> >>>>>>>>>>> Which since even YOU have shown that if H does give the answer of >>>>>>>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>>>>>>> machine, so >>>>>>>>>>> the logic must be wrong. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> It does not halt it has its execution suspended. >>>>>>>>>> If its execution was not suspended it would never halt. >>>>>>>>> >>>>>>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask whether >>>>>>>>> P(P) halts we're not asking about the input to P(P). We're asking >>>>>>>>> about P(P) proper. >>>>>>>> >>>>>>>> *You must be dumber than a box of rocks* >>>>>>>> Do you know know that when any function call (of infinite >>>>>>>> recursion) from the first to the trillionth is aborted that even >>>>>>>> though this infinite recursion stops running IT IS STILL INFINITE >>>>>>>> RECURSION !!! >>>>>>> >>>>>>> >>>>>>> By that "reasoning" (using the term very loosely), when you run >>>>>>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not >>>>>>> only entails that Infinite_Recursion (the thing being simulating) >>>>>>> is non-halting, but also that H (the simulator) is non-halting. >>>>>>> >>>>>> >>>>>> I prove that this is not true by actually showing the steps of >>>>>> infinite recursion being decided: >>>>>> >>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation >>>>>> >>>>>> >>>>>>> Remember that a decider, *by definition* must be guaranteed to halt >>>>>>> and return a result. >>>>>>> >>>>>> >>>>>> I am not dumber than a box of rocks so I already know this. >>>>> >>>>> You seem to be entirely missing my point. >>>>> >>>>> Compare the following: >>>>> >>>>> (1) When we run H(P, P), the topmost H is *not* being simulated. It >>>>> starts simulating its input, and at some point it suspends that >>>>> simulation. >>>>> >>>> >>>> The fact that it must suspend the simulation at one point because the >>>> simulation <is> infinite proves beyond all possible doubt that the >>>> halt decider was correct at that point. >>>> >>>> It does not matter what happens after that point. >>>> It does not matter what happens after that point. >>>> It does not matter what happens after that point. >>>> >>>> If you know that an animal is a cat by testing its DNA then you know >>>> that it is a cat even if this cat barks. >>>> >>>>> (2) When we run P(P), the H at the beginning of the topmost P is >>>>> *not* being simulated. It starts simulating its input and at some >>>>> point it suspends its simulation. >>>>> >>>>> In the first case, you conclude that the input to H is non-halting >>>>> based on the fact that it has been suspended, but you acknowledge >>>>> that H halts. >>>>> >>>> >>>> This is where you <are> dumber than a box of rocks. >>>> This is where you <are> dumber than a box of rocks. >>>> This is where you <are> dumber than a box of rocks. >>>> >>>> It is not that H made some arbitrary decision to suspend its input and >>>> we are relying on this arbitrary decision. >>> >>> Nowhere above do I claim the decision is arbitrary, nor is that relevant >>> to the point I am making. >>> >>>> It is the logical necessity that unless H suspends its input the >>>> simulation of its input is necessarily infinite thus conclusively >>>> proving beyond all possible doubt that P(P) <is> a computation that >>>> never halts. >>>> >>>>> In the second case, you conclude that the input the the H at the >>>>> beginning of the topmost P is non-halting based on the fact that it >>>>> has been suspended, but you somehow also conclude that the topmost P >>>>> does not halt. >>>>> >>>>> How can you claim that the topmost H halts in (1), but that the >>>>> topmost P doesn't halt in (2). These are identical in all respects. >>>>> Either your argument that P(P) doesn't halt is invalid, or your >>>>> reasoning also entails that H(P, P) does not halt (which would >>>>> violate the claim that H is a decider). Which is it? >>>>> >>>>> André >>>>> >>>> >>>> When H can monitor all of the behavior of P(P) H immediately aborts P >>>> before ever returning any value to P. When P has sneaky behavior >>>> behind the back of H, H cannot immediately terminate P. Drug dealers >>>> can get away with bad things until the cops are watching. When the >>>> cops are watching the behavior of the drug dealer is aborted. >>> >>> >>> You seem to be entirely ignoring my question. Do you claim that H(P, P) >>> halts? >>> >> I claim that H(P,P) always correctly decides that its input never halts. >> This remains true no matter what happens after H(P,P) is correctly decided. > > According to GUA https://groups.google.com/g/comp.theory/c/65ZaXe9Sabk, H tries > to decide the (dynamic) property of P that P can defy, thus, H is undecidable. > > Your H is a false teller. When-so-ever any yes/no question lacks a correct yes/no answer this question is incorrect. When-so-ever a TM/input pair to a decision problem lacks a correct Boolean return value the TM/input pair is incorrect. > > -- > Copyright 2021 WIJ > "If I can see further it is by standing on top of the tower of dwarfs." > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-07-13 22:23 -0600 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <hFtHI.12305$Yv3.9482@fx41.iad> |
| In reply to | #36249 |
On 7/13/21 9:02 AM, olcott wrote: > On 7/13/2021 9:54 AM, wij wrote: >> On Tuesday, 13 July 2021 at 22:42:59 UTC+8, olcott wrote: >>> On 7/13/2021 8:57 AM, André G. Isaak wrote: >>>> On 2021-07-13 07:41, olcott wrote: >>>>> On 7/12/2021 7:00 PM, André G. Isaak wrote: >>>>>> On 2021-07-12 16:18, olcott wrote: >>>>>>> On 7/12/2021 1:39 PM, André G. Isaak wrote: >>>>>>>> On 2021-07-12 11:35, olcott wrote: >>>>>>>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>>>>>>>> On 2021-07-12 08:13, olcott wrote: >>>>>>>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>>>>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>>>>>>>> >>>>>>>>>>>>> According to this criteria P(P) specifies a computation that >>>>>>>>>>>>> never halts. >>>>>>>>>>>> >>>>>>>>>>>> Which since even YOU have shown that if H does give the >>>>>>>>>>>> answer of >>>>>>>>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>>>>>>>> machine, so >>>>>>>>>>>> the logic must be wrong. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> It does not halt it has its execution suspended. >>>>>>>>>>> If its execution was not suspended it would never halt. >>>>>>>>>> >>>>>>>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask whether >>>>>>>>>> P(P) halts we're not asking about the input to P(P). We're asking >>>>>>>>>> about P(P) proper. >>>>>>>>> >>>>>>>>> *You must be dumber than a box of rocks* >>>>>>>>> Do you know know that when any function call (of infinite >>>>>>>>> recursion) from the first to the trillionth is aborted that even >>>>>>>>> though this infinite recursion stops running IT IS STILL INFINITE >>>>>>>>> RECURSION !!! >>>>>>>> >>>>>>>> >>>>>>>> By that "reasoning" (using the term very loosely), when you run >>>>>>>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not >>>>>>>> only entails that Infinite_Recursion (the thing being simulating) >>>>>>>> is non-halting, but also that H (the simulator) is non-halting. >>>>>>>> >>>>>>> >>>>>>> I prove that this is not true by actually showing the steps of >>>>>>> infinite recursion being decided: >>>>>>> >>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation >>>>>>> >>>>>>> >>>>>>> >>>>>>>> Remember that a decider, *by definition* must be guaranteed to halt >>>>>>>> and return a result. >>>>>>>> >>>>>>> >>>>>>> I am not dumber than a box of rocks so I already know this. >>>>>> >>>>>> You seem to be entirely missing my point. >>>>>> >>>>>> Compare the following: >>>>>> >>>>>> (1) When we run H(P, P), the topmost H is *not* being simulated. It >>>>>> starts simulating its input, and at some point it suspends that >>>>>> simulation. >>>>>> >>>>> >>>>> The fact that it must suspend the simulation at one point because the >>>>> simulation <is> infinite proves beyond all possible doubt that the >>>>> halt decider was correct at that point. >>>>> >>>>> It does not matter what happens after that point. >>>>> It does not matter what happens after that point. >>>>> It does not matter what happens after that point. >>>>> >>>>> If you know that an animal is a cat by testing its DNA then you know >>>>> that it is a cat even if this cat barks. >>>>> >>>>>> (2) When we run P(P), the H at the beginning of the topmost P is >>>>>> *not* being simulated. It starts simulating its input and at some >>>>>> point it suspends its simulation. >>>>>> >>>>>> In the first case, you conclude that the input to H is non-halting >>>>>> based on the fact that it has been suspended, but you acknowledge >>>>>> that H halts. >>>>>> >>>>> >>>>> This is where you <are> dumber than a box of rocks. >>>>> This is where you <are> dumber than a box of rocks. >>>>> This is where you <are> dumber than a box of rocks. >>>>> >>>>> It is not that H made some arbitrary decision to suspend its input and >>>>> we are relying on this arbitrary decision. >>>> >>>> Nowhere above do I claim the decision is arbitrary, nor is that >>>> relevant >>>> to the point I am making. >>>> >>>>> It is the logical necessity that unless H suspends its input the >>>>> simulation of its input is necessarily infinite thus conclusively >>>>> proving beyond all possible doubt that P(P) <is> a computation that >>>>> never halts. >>>>> >>>>>> In the second case, you conclude that the input the the H at the >>>>>> beginning of the topmost P is non-halting based on the fact that it >>>>>> has been suspended, but you somehow also conclude that the topmost P >>>>>> does not halt. >>>>>> >>>>>> How can you claim that the topmost H halts in (1), but that the >>>>>> topmost P doesn't halt in (2). These are identical in all respects. >>>>>> Either your argument that P(P) doesn't halt is invalid, or your >>>>>> reasoning also entails that H(P, P) does not halt (which would >>>>>> violate the claim that H is a decider). Which is it? >>>>>> >>>>>> André >>>>>> >>>>> >>>>> When H can monitor all of the behavior of P(P) H immediately aborts P >>>>> before ever returning any value to P. When P has sneaky behavior >>>>> behind the back of H, H cannot immediately terminate P. Drug dealers >>>>> can get away with bad things until the cops are watching. When the >>>>> cops are watching the behavior of the drug dealer is aborted. >>>> >>>> >>>> You seem to be entirely ignoring my question. Do you claim that H(P, P) >>>> halts? >>>> >>> I claim that H(P,P) always correctly decides that its input never halts. >>> This remains true no matter what happens after H(P,P) is correctly >>> decided. >> >> According to GUA >> https://groups.google.com/g/comp.theory/c/65ZaXe9Sabk, H tries >> to decide the (dynamic) property of P that P can defy, thus, H is >> undecidable. >> >> Your H is a false teller. > > When-so-ever any yes/no question lacks a correct yes/no answer this > question is incorrect. SO that means your question about what H needs to return is incorrect. Note, the Question of the Halting Problem is does P(I) reach its halt state in a finite number of steps, which given your H, then for P and I being the machine H^ as defined by Linz, their IS a definite answer: YES. H just doesn't give that answer, so is wrong. > > When-so-ever a TM/input pair to a decision problem lacks a correct > Boolean return value the TM/input pair is incorrect. SO actually DEFINE your TM, the problem is you question isn't really about a TM/input pair, but about the design of a TM, so you 'impossible' answer just says that such a TM doesn't exist, so PROVES the theory you are trying to refute. FAIL. > > > >> >> -- >> Copyright 2021 WIJ >> "If I can see further it is by standing on top of the tower of dwarfs." >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-14 15:52 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <8Nidndv-pbwO03L9nZ2dnUU7-RXNnZ2d@giganews.com> |
| In reply to | #36294 |
On 7/13/2021 11:23 PM, Richard Damon wrote: > On 7/13/21 9:02 AM, olcott wrote: >> On 7/13/2021 9:54 AM, wij wrote: >>> On Tuesday, 13 July 2021 at 22:42:59 UTC+8, olcott wrote: >>>> On 7/13/2021 8:57 AM, André G. Isaak wrote: >>>>> On 2021-07-13 07:41, olcott wrote: >>>>>> On 7/12/2021 7:00 PM, André G. Isaak wrote: >>>>>>> On 2021-07-12 16:18, olcott wrote: >>>>>>>> On 7/12/2021 1:39 PM, André G. Isaak wrote: >>>>>>>>> On 2021-07-12 11:35, olcott wrote: >>>>>>>>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>>>>>>>>> On 2021-07-12 08:13, olcott wrote: >>>>>>>>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>>>>>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>>>>>>>>> >>>>>>>>>>>>>> According to this criteria P(P) specifies a computation that >>>>>>>>>>>>>> never halts. >>>>>>>>>>>>> >>>>>>>>>>>>> Which since even YOU have shown that if H does give the >>>>>>>>>>>>> answer of >>>>>>>>>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>>>>>>>>> machine, so >>>>>>>>>>>>> the logic must be wrong. >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> It does not halt it has its execution suspended. >>>>>>>>>>>> If its execution was not suspended it would never halt. >>>>>>>>>>> >>>>>>>>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask whether >>>>>>>>>>> P(P) halts we're not asking about the input to P(P). We're asking >>>>>>>>>>> about P(P) proper. >>>>>>>>>> >>>>>>>>>> *You must be dumber than a box of rocks* >>>>>>>>>> Do you know know that when any function call (of infinite >>>>>>>>>> recursion) from the first to the trillionth is aborted that even >>>>>>>>>> though this infinite recursion stops running IT IS STILL INFINITE >>>>>>>>>> RECURSION !!! >>>>>>>>> >>>>>>>>> >>>>>>>>> By that "reasoning" (using the term very loosely), when you run >>>>>>>>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not >>>>>>>>> only entails that Infinite_Recursion (the thing being simulating) >>>>>>>>> is non-halting, but also that H (the simulator) is non-halting. >>>>>>>>> >>>>>>>> >>>>>>>> I prove that this is not true by actually showing the steps of >>>>>>>> infinite recursion being decided: >>>>>>>> >>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation >>>>>>>> >>>>>>>> >>>>>>>> >>>>>>>>> Remember that a decider, *by definition* must be guaranteed to halt >>>>>>>>> and return a result. >>>>>>>>> >>>>>>>> >>>>>>>> I am not dumber than a box of rocks so I already know this. >>>>>>> >>>>>>> You seem to be entirely missing my point. >>>>>>> >>>>>>> Compare the following: >>>>>>> >>>>>>> (1) When we run H(P, P), the topmost H is *not* being simulated. It >>>>>>> starts simulating its input, and at some point it suspends that >>>>>>> simulation. >>>>>>> >>>>>> >>>>>> The fact that it must suspend the simulation at one point because the >>>>>> simulation <is> infinite proves beyond all possible doubt that the >>>>>> halt decider was correct at that point. >>>>>> >>>>>> It does not matter what happens after that point. >>>>>> It does not matter what happens after that point. >>>>>> It does not matter what happens after that point. >>>>>> >>>>>> If you know that an animal is a cat by testing its DNA then you know >>>>>> that it is a cat even if this cat barks. >>>>>> >>>>>>> (2) When we run P(P), the H at the beginning of the topmost P is >>>>>>> *not* being simulated. It starts simulating its input and at some >>>>>>> point it suspends its simulation. >>>>>>> >>>>>>> In the first case, you conclude that the input to H is non-halting >>>>>>> based on the fact that it has been suspended, but you acknowledge >>>>>>> that H halts. >>>>>>> >>>>>> >>>>>> This is where you <are> dumber than a box of rocks. >>>>>> This is where you <are> dumber than a box of rocks. >>>>>> This is where you <are> dumber than a box of rocks. >>>>>> >>>>>> It is not that H made some arbitrary decision to suspend its input and >>>>>> we are relying on this arbitrary decision. >>>>> >>>>> Nowhere above do I claim the decision is arbitrary, nor is that >>>>> relevant >>>>> to the point I am making. >>>>> >>>>>> It is the logical necessity that unless H suspends its input the >>>>>> simulation of its input is necessarily infinite thus conclusively >>>>>> proving beyond all possible doubt that P(P) <is> a computation that >>>>>> never halts. >>>>>> >>>>>>> In the second case, you conclude that the input the the H at the >>>>>>> beginning of the topmost P is non-halting based on the fact that it >>>>>>> has been suspended, but you somehow also conclude that the topmost P >>>>>>> does not halt. >>>>>>> >>>>>>> How can you claim that the topmost H halts in (1), but that the >>>>>>> topmost P doesn't halt in (2). These are identical in all respects. >>>>>>> Either your argument that P(P) doesn't halt is invalid, or your >>>>>>> reasoning also entails that H(P, P) does not halt (which would >>>>>>> violate the claim that H is a decider). Which is it? >>>>>>> >>>>>>> André >>>>>>> >>>>>> >>>>>> When H can monitor all of the behavior of P(P) H immediately aborts P >>>>>> before ever returning any value to P. When P has sneaky behavior >>>>>> behind the back of H, H cannot immediately terminate P. Drug dealers >>>>>> can get away with bad things until the cops are watching. When the >>>>>> cops are watching the behavior of the drug dealer is aborted. >>>>> >>>>> >>>>> You seem to be entirely ignoring my question. Do you claim that H(P, P) >>>>> halts? >>>>> >>>> I claim that H(P,P) always correctly decides that its input never halts. >>>> This remains true no matter what happens after H(P,P) is correctly >>>> decided. >>> >>> According to GUA >>> https://groups.google.com/g/comp.theory/c/65ZaXe9Sabk, H tries >>> to decide the (dynamic) property of P that P can defy, thus, H is >>> undecidable. >>> >>> Your H is a false teller. >> >> When-so-ever any yes/no question lacks a correct yes/no answer this >> question is incorrect. > > SO that means your question about what H needs to return is incorrect. > > Note, the Question of the Halting Problem is does P(I) reach its halt > state in a finite number of steps, which given your H, then for P and I > being the machine H^ as defined by Linz, their IS a definite answer: YES. > > H just doesn't give that answer, so is wrong. The question of the halting problem is exactly like the question: Have you stopped beating your wife? The context matters. When you ask a guy that has never been married the question is incorrect because both yes and no are the wrong answer. When you ask a guy that is married and has beaten his wife then exactly one of yes or no is the correct answer. When you ask whether or not a program halts on its input and you are asking what Boolean value can a TM correctly return to its input when its input does the opposite of whatever value the TM returns, this is an incorrect question when all of the context of the question is considered because both Boolean values are the wrong return value. We are not asking whether or not the input halts on its input that question always has a correct answer for every TM / input pair. We are asking which Boolean value can H return to P is the correct halt status of P? false is wrong, true is wrong thus the question is wrong. >> >> When-so-ever a TM/input pair to a decision problem lacks a correct >> Boolean return value the TM/input pair is incorrect. > > SO actually DEFINE your TM, the problem is you question isn't really > about a TM/input pair, but about the design of a TM, so you 'impossible' > answer just says that such a TM doesn't exist, so PROVES the theory you > are trying to refute. > > > FAIL. > >> >> >> >>> >>> -- >>> Copyright 2021 WIJ >>> "If I can see further it is by standing on top of the tower of dwarfs." >>> >> >> > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Andy Walker <anw@cuboid.co.uk> |
|---|---|
| Date | 2021-07-14 22:09 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <scnjpq$1f4n$1@gioia.aioe.org> |
| In reply to | #36311 |
On 14/07/2021 21:52, olcott wrote:
[...]
> We are not asking whether or not the input halts on its input that
> question always has a correct answer for every TM / input pair.
> We are asking which Boolean value can H return to P is the correct
> halt status of P? false is wrong, true is wrong thus the question is
> wrong.
So near and yet so far! /You/ are asking the second question,
the rest of us are asking the first.
--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Couperin
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-14 16:47 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <eJSdnVmyGIQexnL9nZ2dnUU7-bfNnZ2d@giganews.com> |
| In reply to | #36314 |
On 7/14/2021 4:09 PM, Andy Walker wrote: > On 14/07/2021 21:52, olcott wrote: > [...] >> We are not asking whether or not the input halts on its input that >> question always has a correct answer for every TM / input pair. >> We are asking which Boolean value can H return to P is the correct >> halt status of P? false is wrong, true is wrong thus the question is >> wrong. > > So near and yet so far! /You/ are asking the second question, > the rest of us are asking the first. > When the halting problem is applied to a TM/input such that the TM must return a halt status value to an input that does the opposite of whatever it decides both true and false are incorrect return values thus proving the error in this precise context of the halting problem. Woefully dishonest people continually ignore this key context. When we ask a man that has never been married: Have you stopped beating your wife? the context (that he has never been married) makes the question itself incorrect. It is the same context (that the input P does the opposite of whatever H decides) that makes the halting problem question incorrect in this case. My H does provide the correct answer because it essentially tells its input P to shut the Hell up by aborting its whole process. https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-07-14 21:03 -0600 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <PzNHI.2585$5Y6.1347@fx10.iad> |
| In reply to | #36317 |
On 7/14/21 3:47 PM, olcott wrote: > On 7/14/2021 4:09 PM, Andy Walker wrote: >> On 14/07/2021 21:52, olcott wrote: >> [...] >>> We are not asking whether or not the input halts on its input that >>> question always has a correct answer for every TM / input pair. >>> We are asking which Boolean value can H return to P is the correct >>> halt status of P? false is wrong, true is wrong thus the question is >>> wrong. >> >> So near and yet so far! /You/ are asking the second question, >> the rest of us are asking the first. >> > > When the halting problem is applied to a TM/input such that the TM must > return a halt status value to an input that does the opposite of > whatever it decides both true and false are incorrect return values thus > proving the error in this precise context of the halting problem. > WRONG. UNSOUND LOGIC. You are presuming that you CAN create a machine that always answer the question correctly. THIS IS NOT A GIVEN. THe fact that you can not build an H that can give the right answer to a machine that is built on H is NOT a contradiction. It just shows that no H can exist that gets the answer right, not that there isn't a right answer to the REAL Haltig Problem Question. > Woefully dishonest people continually ignore this key context. > When we ask a man that has never been married: > Have you stopped beating your wife? So Have You? Or better yet, "Will you stop making dumb arguments?" > the context (that he has never been married) makes the question itself > incorrect. > > It is the same context (that the input P does the opposite of whatever H > decides) that makes the halting problem question incorrect in this case. > > My H does provide the correct answer because it essentially tells its > input P to shut the Hell up by aborting its whole process. > > https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation > >
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-07-14 20:57 -0600 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <PuNHI.6604$kn7.2739@fx19.iad> |
| In reply to | #36311 |
On 7/14/21 2:52 PM, olcott wrote: > On 7/13/2021 11:23 PM, Richard Damon wrote: >> On 7/13/21 9:02 AM, olcott wrote: >>> On 7/13/2021 9:54 AM, wij wrote: >>>> On Tuesday, 13 July 2021 at 22:42:59 UTC+8, olcott wrote: >>>>> On 7/13/2021 8:57 AM, André G. Isaak wrote: >>>>>> On 2021-07-13 07:41, olcott wrote: >>>>>>> On 7/12/2021 7:00 PM, André G. Isaak wrote: >>>>>>>> On 2021-07-12 16:18, olcott wrote: >>>>>>>>> On 7/12/2021 1:39 PM, André G. Isaak wrote: >>>>>>>>>> On 2021-07-12 11:35, olcott wrote: >>>>>>>>>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>>>>>>>>>> On 2021-07-12 08:13, olcott wrote: >>>>>>>>>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>>>>>>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>>>>>>>>>> >>>>>>>>>>>>>>> According to this criteria P(P) specifies a computation that >>>>>>>>>>>>>>> never halts. >>>>>>>>>>>>>> >>>>>>>>>>>>>> Which since even YOU have shown that if H does give the >>>>>>>>>>>>>> answer of >>>>>>>>>>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>>>>>>>>>> machine, so >>>>>>>>>>>>>> the logic must be wrong. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> It does not halt it has its execution suspended. >>>>>>>>>>>>> If its execution was not suspended it would never halt. >>>>>>>>>>>> >>>>>>>>>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask >>>>>>>>>>>> whether >>>>>>>>>>>> P(P) halts we're not asking about the input to P(P). We're >>>>>>>>>>>> asking >>>>>>>>>>>> about P(P) proper. >>>>>>>>>>> >>>>>>>>>>> *You must be dumber than a box of rocks* >>>>>>>>>>> Do you know know that when any function call (of infinite >>>>>>>>>>> recursion) from the first to the trillionth is aborted that even >>>>>>>>>>> though this infinite recursion stops running IT IS STILL >>>>>>>>>>> INFINITE >>>>>>>>>>> RECURSION !!! >>>>>>>>>> >>>>>>>>>> >>>>>>>>>> By that "reasoning" (using the term very loosely), when you run >>>>>>>>>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not >>>>>>>>>> only entails that Infinite_Recursion (the thing being simulating) >>>>>>>>>> is non-halting, but also that H (the simulator) is non-halting. >>>>>>>>>> >>>>>>>>> >>>>>>>>> I prove that this is not true by actually showing the steps of >>>>>>>>> infinite recursion being decided: >>>>>>>>> >>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation >>>>>>>>> >>>>>>>>> >>>>>>>>> >>>>>>>>> >>>>>>>>>> Remember that a decider, *by definition* must be guaranteed to >>>>>>>>>> halt >>>>>>>>>> and return a result. >>>>>>>>>> >>>>>>>>> >>>>>>>>> I am not dumber than a box of rocks so I already know this. >>>>>>>> >>>>>>>> You seem to be entirely missing my point. >>>>>>>> >>>>>>>> Compare the following: >>>>>>>> >>>>>>>> (1) When we run H(P, P), the topmost H is *not* being simulated. It >>>>>>>> starts simulating its input, and at some point it suspends that >>>>>>>> simulation. >>>>>>>> >>>>>>> >>>>>>> The fact that it must suspend the simulation at one point because >>>>>>> the >>>>>>> simulation <is> infinite proves beyond all possible doubt that the >>>>>>> halt decider was correct at that point. >>>>>>> >>>>>>> It does not matter what happens after that point. >>>>>>> It does not matter what happens after that point. >>>>>>> It does not matter what happens after that point. >>>>>>> >>>>>>> If you know that an animal is a cat by testing its DNA then you know >>>>>>> that it is a cat even if this cat barks. >>>>>>> >>>>>>>> (2) When we run P(P), the H at the beginning of the topmost P is >>>>>>>> *not* being simulated. It starts simulating its input and at some >>>>>>>> point it suspends its simulation. >>>>>>>> >>>>>>>> In the first case, you conclude that the input to H is non-halting >>>>>>>> based on the fact that it has been suspended, but you acknowledge >>>>>>>> that H halts. >>>>>>>> >>>>>>> >>>>>>> This is where you <are> dumber than a box of rocks. >>>>>>> This is where you <are> dumber than a box of rocks. >>>>>>> This is where you <are> dumber than a box of rocks. >>>>>>> >>>>>>> It is not that H made some arbitrary decision to suspend its >>>>>>> input and >>>>>>> we are relying on this arbitrary decision. >>>>>> >>>>>> Nowhere above do I claim the decision is arbitrary, nor is that >>>>>> relevant >>>>>> to the point I am making. >>>>>> >>>>>>> It is the logical necessity that unless H suspends its input the >>>>>>> simulation of its input is necessarily infinite thus conclusively >>>>>>> proving beyond all possible doubt that P(P) <is> a computation that >>>>>>> never halts. >>>>>>> >>>>>>>> In the second case, you conclude that the input the the H at the >>>>>>>> beginning of the topmost P is non-halting based on the fact that it >>>>>>>> has been suspended, but you somehow also conclude that the >>>>>>>> topmost P >>>>>>>> does not halt. >>>>>>>> >>>>>>>> How can you claim that the topmost H halts in (1), but that the >>>>>>>> topmost P doesn't halt in (2). These are identical in all respects. >>>>>>>> Either your argument that P(P) doesn't halt is invalid, or your >>>>>>>> reasoning also entails that H(P, P) does not halt (which would >>>>>>>> violate the claim that H is a decider). Which is it? >>>>>>>> >>>>>>>> André >>>>>>>> >>>>>>> >>>>>>> When H can monitor all of the behavior of P(P) H immediately >>>>>>> aborts P >>>>>>> before ever returning any value to P. When P has sneaky behavior >>>>>>> behind the back of H, H cannot immediately terminate P. Drug dealers >>>>>>> can get away with bad things until the cops are watching. When the >>>>>>> cops are watching the behavior of the drug dealer is aborted. >>>>>> >>>>>> >>>>>> You seem to be entirely ignoring my question. Do you claim that >>>>>> H(P, P) >>>>>> halts? >>>>>> >>>>> I claim that H(P,P) always correctly decides that its input never >>>>> halts. >>>>> This remains true no matter what happens after H(P,P) is correctly >>>>> decided. >>>> >>>> According to GUA >>>> https://groups.google.com/g/comp.theory/c/65ZaXe9Sabk, H tries >>>> to decide the (dynamic) property of P that P can defy, thus, H is >>>> undecidable. >>>> >>>> Your H is a false teller. >>> >>> When-so-ever any yes/no question lacks a correct yes/no answer this >>> question is incorrect. >> >> SO that means your question about what H needs to return is incorrect. >> >> Note, the Question of the Halting Problem is does P(I) reach its halt >> state in a finite number of steps, which given your H, then for P and I >> being the machine H^ as defined by Linz, their IS a definite answer: YES. >> >> H just doesn't give that answer, so is wrong. > > The question of the halting problem is exactly like the question: > Have you stopped beating your wife? Well Have you? And actually, it isn't. The REAL question of the Halting Problem is "Does the Turing Machine P given input I come to a halting state in a finite number of steps, or not?" THIS question ALWAYS has a correct answer, as it will ALWAYS be either Yes it Halts, or No it never halts. > > The context matters. > When you ask a guy that has never been married the question is incorrect > because both yes and no are the wrong answer. So in what context does a Turing Machine neither Halt or Not-Halt? The only case I can think of is if it isn't a Turing Machine, but the question is only asked of Turing Machines. Yes, YOUR WRONG question can be a bit like that, > > When you ask a guy that is married and has beaten his wife then exactly > one of yes or no is the correct answer. But this isn't the case. > > When you ask whether or not a program halts on its input and you are > asking what Boolean value can a TM correctly return to its input when > its input does the opposite of whatever value the TM returns, this is an > incorrect question when all of the context of the question is considered > because both Boolean values are the wrong return value. You have it wrong here. There IS a right answer to the question of P(I) halting. H can never give that answer, in part because H has to be fixed before H^ (which you are calling P) is created. There is NO contradiction here, H is just wrong. There is NO rule that you can quote to say that there has to be an H that can get this problem right. NONE. That is the flaw in your argument, you PRESUME that there exists a machine that can universally answer the Question of the Halting Problem, when there actually is none. > > We are not asking whether or not the input halts on its input that > question always has a correct answer for every TM / input pair. And why not, that IS the Question of the Halting Problem? Which even youy agree always has an answer. > > We are asking which Boolean value can H return to P is the correct halt > status of P? false is wrong, true is wrong thus the question is wrong. And as said above, this is NOT the question of the Halting Problem. This is the question needed to be solved to DESIGN a Halting Decider that can counter something like the Linz proof. Your proof that there is no right answer just reconfirms Linz and the like, showing that it is impossible to design an H that can correctly answer to the H^ machine made from it. (I perfectly legal Turing Machine Transform). And this gets back to the one exception to the rule that all Turing Machine have a definite answer that the Halt or they are Non-Halting, if H doesn't exist, then neither does H^, so H^(H^) isn't a Turing Machine and doesn't need to Halt or not. FAIR WARNING. You have made this same arguement many times, and totally ignore the responses that show you are wrong. If you fail to actually provide a REAL SOUND ANALYTICAL argument showing an error in this rebuttal, I reserve the right to just refer to this message to indicate that you arguement has been disproven and anythig that follows from it is thus an unsound argument.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-14 22:12 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <ZKGdnXf__7kEOnL9nZ2dnUU7-cXNnZ2d@giganews.com> |
| In reply to | #36320 |
On 7/14/2021 9:57 PM, Richard Damon wrote: > On 7/14/21 2:52 PM, olcott wrote: >> On 7/13/2021 11:23 PM, Richard Damon wrote: >>> On 7/13/21 9:02 AM, olcott wrote: >>>> On 7/13/2021 9:54 AM, wij wrote: >>>>> On Tuesday, 13 July 2021 at 22:42:59 UTC+8, olcott wrote: >>>>>> On 7/13/2021 8:57 AM, André G. Isaak wrote: >>>>>>> On 2021-07-13 07:41, olcott wrote: >>>>>>>> On 7/12/2021 7:00 PM, André G. Isaak wrote: >>>>>>>>> On 2021-07-12 16:18, olcott wrote: >>>>>>>>>> On 7/12/2021 1:39 PM, André G. Isaak wrote: >>>>>>>>>>> On 2021-07-12 11:35, olcott wrote: >>>>>>>>>>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>>>>>>>>>>> On 2021-07-12 08:13, olcott wrote: >>>>>>>>>>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>>>>>>>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> According to this criteria P(P) specifies a computation that >>>>>>>>>>>>>>>> never halts. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Which since even YOU have shown that if H does give the >>>>>>>>>>>>>>> answer of >>>>>>>>>>>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>>>>>>>>>>> machine, so >>>>>>>>>>>>>>> the logic must be wrong. >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> It does not halt it has its execution suspended. >>>>>>>>>>>>>> If its execution was not suspended it would never halt. >>>>>>>>>>>>> >>>>>>>>>>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask >>>>>>>>>>>>> whether >>>>>>>>>>>>> P(P) halts we're not asking about the input to P(P). We're >>>>>>>>>>>>> asking >>>>>>>>>>>>> about P(P) proper. >>>>>>>>>>>> >>>>>>>>>>>> *You must be dumber than a box of rocks* >>>>>>>>>>>> Do you know know that when any function call (of infinite >>>>>>>>>>>> recursion) from the first to the trillionth is aborted that even >>>>>>>>>>>> though this infinite recursion stops running IT IS STILL >>>>>>>>>>>> INFINITE >>>>>>>>>>>> RECURSION !!! >>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> By that "reasoning" (using the term very loosely), when you run >>>>>>>>>>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not >>>>>>>>>>> only entails that Infinite_Recursion (the thing being simulating) >>>>>>>>>>> is non-halting, but also that H (the simulator) is non-halting. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> I prove that this is not true by actually showing the steps of >>>>>>>>>> infinite recursion being decided: >>>>>>>>>> >>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation >>>>>>>>>> >>>>>>>>>> >>>>>>>>>> >>>>>>>>>> >>>>>>>>>>> Remember that a decider, *by definition* must be guaranteed to >>>>>>>>>>> halt >>>>>>>>>>> and return a result. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> I am not dumber than a box of rocks so I already know this. >>>>>>>>> >>>>>>>>> You seem to be entirely missing my point. >>>>>>>>> >>>>>>>>> Compare the following: >>>>>>>>> >>>>>>>>> (1) When we run H(P, P), the topmost H is *not* being simulated. It >>>>>>>>> starts simulating its input, and at some point it suspends that >>>>>>>>> simulation. >>>>>>>>> >>>>>>>> >>>>>>>> The fact that it must suspend the simulation at one point because >>>>>>>> the >>>>>>>> simulation <is> infinite proves beyond all possible doubt that the >>>>>>>> halt decider was correct at that point. >>>>>>>> >>>>>>>> It does not matter what happens after that point. >>>>>>>> It does not matter what happens after that point. >>>>>>>> It does not matter what happens after that point. >>>>>>>> >>>>>>>> If you know that an animal is a cat by testing its DNA then you know >>>>>>>> that it is a cat even if this cat barks. >>>>>>>> >>>>>>>>> (2) When we run P(P), the H at the beginning of the topmost P is >>>>>>>>> *not* being simulated. It starts simulating its input and at some >>>>>>>>> point it suspends its simulation. >>>>>>>>> >>>>>>>>> In the first case, you conclude that the input to H is non-halting >>>>>>>>> based on the fact that it has been suspended, but you acknowledge >>>>>>>>> that H halts. >>>>>>>>> >>>>>>>> >>>>>>>> This is where you <are> dumber than a box of rocks. >>>>>>>> This is where you <are> dumber than a box of rocks. >>>>>>>> This is where you <are> dumber than a box of rocks. >>>>>>>> >>>>>>>> It is not that H made some arbitrary decision to suspend its >>>>>>>> input and >>>>>>>> we are relying on this arbitrary decision. >>>>>>> >>>>>>> Nowhere above do I claim the decision is arbitrary, nor is that >>>>>>> relevant >>>>>>> to the point I am making. >>>>>>> >>>>>>>> It is the logical necessity that unless H suspends its input the >>>>>>>> simulation of its input is necessarily infinite thus conclusively >>>>>>>> proving beyond all possible doubt that P(P) <is> a computation that >>>>>>>> never halts. >>>>>>>> >>>>>>>>> In the second case, you conclude that the input the the H at the >>>>>>>>> beginning of the topmost P is non-halting based on the fact that it >>>>>>>>> has been suspended, but you somehow also conclude that the >>>>>>>>> topmost P >>>>>>>>> does not halt. >>>>>>>>> >>>>>>>>> How can you claim that the topmost H halts in (1), but that the >>>>>>>>> topmost P doesn't halt in (2). These are identical in all respects. >>>>>>>>> Either your argument that P(P) doesn't halt is invalid, or your >>>>>>>>> reasoning also entails that H(P, P) does not halt (which would >>>>>>>>> violate the claim that H is a decider). Which is it? >>>>>>>>> >>>>>>>>> André >>>>>>>>> >>>>>>>> >>>>>>>> When H can monitor all of the behavior of P(P) H immediately >>>>>>>> aborts P >>>>>>>> before ever returning any value to P. When P has sneaky behavior >>>>>>>> behind the back of H, H cannot immediately terminate P. Drug dealers >>>>>>>> can get away with bad things until the cops are watching. When the >>>>>>>> cops are watching the behavior of the drug dealer is aborted. >>>>>>> >>>>>>> >>>>>>> You seem to be entirely ignoring my question. Do you claim that >>>>>>> H(P, P) >>>>>>> halts? >>>>>>> >>>>>> I claim that H(P,P) always correctly decides that its input never >>>>>> halts. >>>>>> This remains true no matter what happens after H(P,P) is correctly >>>>>> decided. >>>>> >>>>> According to GUA >>>>> https://groups.google.com/g/comp.theory/c/65ZaXe9Sabk, H tries >>>>> to decide the (dynamic) property of P that P can defy, thus, H is >>>>> undecidable. >>>>> >>>>> Your H is a false teller. >>>> >>>> When-so-ever any yes/no question lacks a correct yes/no answer this >>>> question is incorrect. >>> >>> SO that means your question about what H needs to return is incorrect. >>> >>> Note, the Question of the Halting Problem is does P(I) reach its halt >>> state in a finite number of steps, which given your H, then for P and I >>> being the machine H^ as defined by Linz, their IS a definite answer: YES. >>> >>> H just doesn't give that answer, so is wrong. >> >> The question of the halting problem is exactly like the question: >> Have you stopped beating your wife? > > Well Have you? > > And actually, it isn't. > > The REAL question of the Halting Problem is "Does the Turing Machine P > given input I come to a halting state in a finite number of steps, or not?" > When you provide the context of a TM/input pair then the brand new idea that I created "incorrect question" is formed: When-so-ever a yes/no question has no correct answer from the set of yes/no or a decision problem TM/input pair has has no final state indicting a correct Boolean value then it is an error. Undecidability has always only been an error. It is not that the correct true/false value cannot be chosen by the TM. It is that both true/false values are the wrong answer. In my case this issue is solved. H(P,P) always aborts its input never returning any value to its input. > THIS question ALWAYS has a correct answer, as it will ALWAYS be either > Yes it Halts, or No it never halts. >> >> The context matters. >> When you ask a guy that has never been married the question is incorrect >> because both yes and no are the wrong answer. > > So in what context does a Turing Machine neither Halt or Not-Halt? The > only case I can think of is if it isn't a Turing Machine, but the > question is only asked of Turing Machines. > > Yes, YOUR WRONG question can be a bit like that, >> >> When you ask a guy that is married and has beaten his wife then exactly >> one of yes or no is the correct answer. > > But this isn't the case. >> >> When you ask whether or not a program halts on its input and you are >> asking what Boolean value can a TM correctly return to its input when >> its input does the opposite of whatever value the TM returns, this is an >> incorrect question when all of the context of the question is considered >> because both Boolean values are the wrong return value. > > You have it wrong here. There IS a right answer to the question of P(I) > halting. H can never give that answer, in part because H has to be fixed > before H^ (which you are calling P) is created. There is NO > contradiction here, H is just wrong. There is NO rule that you can quote > to say that there has to be an H that can get this problem right. NONE. > > That is the flaw in your argument, you PRESUME that there exists a > machine that can universally answer the Question of the Halting Problem, > when there actually is none. > >> >> We are not asking whether or not the input halts on its input that >> question always has a correct answer for every TM / input pair. > > And why not, that IS the Question of the Halting Problem? Which even > youy agree always has an answer. >> >> We are asking which Boolean value can H return to P is the correct halt >> status of P? false is wrong, true is wrong thus the question is wrong. > > And as said above, this is NOT the question of the Halting Problem. > > This is the question needed to be solved to DESIGN a Halting Decider > that can counter something like the Linz proof. Your proof that there is > no right answer just reconfirms Linz and the like, showing that it is > impossible to design an H that can correctly answer to the H^ machine > made from it. (I perfectly legal Turing Machine Transform). > > And this gets back to the one exception to the rule that all Turing > Machine have a definite answer that the Halt or they are Non-Halting, if > H doesn't exist, then neither does H^, so H^(H^) isn't a Turing Machine > and doesn't need to Halt or not. > > > FAIR WARNING. > > You have made this same arguement many times, and totally ignore the > responses that show you are wrong. > > If you fail to actually provide a REAL SOUND ANALYTICAL argument showing > an error in this rebuttal, I reserve the right to just refer to this > message to indicate that you arguement has been disproven and anythig > that follows from it is thus an unsound argument. > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-07-14 21:57 -0600 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <YmOHI.6927$tL2.5020@fx43.iad> |
| In reply to | #36323 |
On 7/14/21 9:12 PM, olcott wrote: > On 7/14/2021 9:57 PM, Richard Damon wrote: >> On 7/14/21 2:52 PM, olcott wrote: >>> On 7/13/2021 11:23 PM, Richard Damon wrote: >>>> On 7/13/21 9:02 AM, olcott wrote: >>>>> On 7/13/2021 9:54 AM, wij wrote: >>>>>> On Tuesday, 13 July 2021 at 22:42:59 UTC+8, olcott wrote: >>>>>>> On 7/13/2021 8:57 AM, André G. Isaak wrote: >>>>>>>> On 2021-07-13 07:41, olcott wrote: >>>>>>>>> On 7/12/2021 7:00 PM, André G. Isaak wrote: >>>>>>>>>> On 2021-07-12 16:18, olcott wrote: >>>>>>>>>>> On 7/12/2021 1:39 PM, André G. Isaak wrote: >>>>>>>>>>>> On 2021-07-12 11:35, olcott wrote: >>>>>>>>>>>>> On 7/12/2021 10:20 AM, André G. Isaak wrote: >>>>>>>>>>>>>> On 2021-07-12 08:13, olcott wrote: >>>>>>>>>>>>>>> On 7/11/2021 11:35 PM, Richard Damon wrote: >>>>>>>>>>>>>>>> On 7/11/21 9:30 AM, olcott wrote: >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> According to this criteria P(P) specifies a computation >>>>>>>>>>>>>>>>> that >>>>>>>>>>>>>>>>> never halts. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Which since even YOU have shown that if H does give the >>>>>>>>>>>>>>>> answer of >>>>>>>>>>>>>>>> Non-Halting, that P(P) will halt when run as an independent >>>>>>>>>>>>>>>> machine, so >>>>>>>>>>>>>>>> the logic must be wrong. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> It does not halt it has its execution suspended. >>>>>>>>>>>>>>> If its execution was not suspended it would never halt. >>>>>>>>>>>>>> >>>>>>>>>>>>>> The SIMULATION OF ITS INPUT is suspended. But when we ask >>>>>>>>>>>>>> whether >>>>>>>>>>>>>> P(P) halts we're not asking about the input to P(P). We're >>>>>>>>>>>>>> asking >>>>>>>>>>>>>> about P(P) proper. >>>>>>>>>>>>> >>>>>>>>>>>>> *You must be dumber than a box of rocks* >>>>>>>>>>>>> Do you know know that when any function call (of infinite >>>>>>>>>>>>> recursion) from the first to the trillionth is aborted that >>>>>>>>>>>>> even >>>>>>>>>>>>> though this infinite recursion stops running IT IS STILL >>>>>>>>>>>>> INFINITE >>>>>>>>>>>>> RECURSION !!! >>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> By that "reasoning" (using the term very loosely), when you run >>>>>>>>>>>> H(Infinite_Recursion) and H suspends Infinite_recursion, it not >>>>>>>>>>>> only entails that Infinite_Recursion (the thing being >>>>>>>>>>>> simulating) >>>>>>>>>>>> is non-halting, but also that H (the simulator) is non-halting. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> I prove that this is not true by actually showing the steps of >>>>>>>>>>> infinite recursion being decided: >>>>>>>>>>> >>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation >>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>>> Remember that a decider, *by definition* must be guaranteed to >>>>>>>>>>>> halt >>>>>>>>>>>> and return a result. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> I am not dumber than a box of rocks so I already know this. >>>>>>>>>> >>>>>>>>>> You seem to be entirely missing my point. >>>>>>>>>> >>>>>>>>>> Compare the following: >>>>>>>>>> >>>>>>>>>> (1) When we run H(P, P), the topmost H is *not* being >>>>>>>>>> simulated. It >>>>>>>>>> starts simulating its input, and at some point it suspends that >>>>>>>>>> simulation. >>>>>>>>>> >>>>>>>>> >>>>>>>>> The fact that it must suspend the simulation at one point because >>>>>>>>> the >>>>>>>>> simulation <is> infinite proves beyond all possible doubt that the >>>>>>>>> halt decider was correct at that point. >>>>>>>>> >>>>>>>>> It does not matter what happens after that point. >>>>>>>>> It does not matter what happens after that point. >>>>>>>>> It does not matter what happens after that point. >>>>>>>>> >>>>>>>>> If you know that an animal is a cat by testing its DNA then you >>>>>>>>> know >>>>>>>>> that it is a cat even if this cat barks. >>>>>>>>> >>>>>>>>>> (2) When we run P(P), the H at the beginning of the topmost P is >>>>>>>>>> *not* being simulated. It starts simulating its input and at some >>>>>>>>>> point it suspends its simulation. >>>>>>>>>> >>>>>>>>>> In the first case, you conclude that the input to H is >>>>>>>>>> non-halting >>>>>>>>>> based on the fact that it has been suspended, but you acknowledge >>>>>>>>>> that H halts. >>>>>>>>>> >>>>>>>>> >>>>>>>>> This is where you <are> dumber than a box of rocks. >>>>>>>>> This is where you <are> dumber than a box of rocks. >>>>>>>>> This is where you <are> dumber than a box of rocks. >>>>>>>>> >>>>>>>>> It is not that H made some arbitrary decision to suspend its >>>>>>>>> input and >>>>>>>>> we are relying on this arbitrary decision. >>>>>>>> >>>>>>>> Nowhere above do I claim the decision is arbitrary, nor is that >>>>>>>> relevant >>>>>>>> to the point I am making. >>>>>>>> >>>>>>>>> It is the logical necessity that unless H suspends its input the >>>>>>>>> simulation of its input is necessarily infinite thus conclusively >>>>>>>>> proving beyond all possible doubt that P(P) <is> a computation >>>>>>>>> that >>>>>>>>> never halts. >>>>>>>>> >>>>>>>>>> In the second case, you conclude that the input the the H at the >>>>>>>>>> beginning of the topmost P is non-halting based on the fact >>>>>>>>>> that it >>>>>>>>>> has been suspended, but you somehow also conclude that the >>>>>>>>>> topmost P >>>>>>>>>> does not halt. >>>>>>>>>> >>>>>>>>>> How can you claim that the topmost H halts in (1), but that the >>>>>>>>>> topmost P doesn't halt in (2). These are identical in all >>>>>>>>>> respects. >>>>>>>>>> Either your argument that P(P) doesn't halt is invalid, or your >>>>>>>>>> reasoning also entails that H(P, P) does not halt (which would >>>>>>>>>> violate the claim that H is a decider). Which is it? >>>>>>>>>> >>>>>>>>>> André >>>>>>>>>> >>>>>>>>> >>>>>>>>> When H can monitor all of the behavior of P(P) H immediately >>>>>>>>> aborts P >>>>>>>>> before ever returning any value to P. When P has sneaky behavior >>>>>>>>> behind the back of H, H cannot immediately terminate P. Drug >>>>>>>>> dealers >>>>>>>>> can get away with bad things until the cops are watching. When the >>>>>>>>> cops are watching the behavior of the drug dealer is aborted. >>>>>>>> >>>>>>>> >>>>>>>> You seem to be entirely ignoring my question. Do you claim that >>>>>>>> H(P, P) >>>>>>>> halts? >>>>>>>> >>>>>>> I claim that H(P,P) always correctly decides that its input never >>>>>>> halts. >>>>>>> This remains true no matter what happens after H(P,P) is correctly >>>>>>> decided. >>>>>> >>>>>> According to GUA >>>>>> https://groups.google.com/g/comp.theory/c/65ZaXe9Sabk, H tries >>>>>> to decide the (dynamic) property of P that P can defy, thus, H is >>>>>> undecidable. >>>>>> >>>>>> Your H is a false teller. >>>>> >>>>> When-so-ever any yes/no question lacks a correct yes/no answer this >>>>> question is incorrect. >>>> >>>> SO that means your question about what H needs to return is incorrect. >>>> >>>> Note, the Question of the Halting Problem is does P(I) reach its halt >>>> state in a finite number of steps, which given your H, then for P and I >>>> being the machine H^ as defined by Linz, their IS a definite answer: >>>> YES. >>>> >>>> H just doesn't give that answer, so is wrong. >>> >>> The question of the halting problem is exactly like the question: >>> Have you stopped beating your wife? >> >> Well Have you? >> >> And actually, it isn't. >> >> The REAL question of the Halting Problem is "Does the Turing Machine P >> given input I come to a halting state in a finite number of steps, or >> not?" >> > > When you provide the context of a TM/input pair then the brand new idea > that I created "incorrect question" is formed: > > When-so-ever a yes/no question has no correct answer from the set of > yes/no or a decision problem TM/input pair has has no final state > indicting a correct Boolean value then it is an error. UNRESPONSIVE. You can NOT change the basis of a Theorem and claim to be working on it at the same time, ZERO grounds for the alternate question. The Actual question for the Halting problem has an answer that exists, and for the case in view the answer is that H^(H^) for your H is a Halting Computation and H gave the wrong answer. Your statement is still DISPROVEN. FAIL. > > Undecidability has always only been an error. > It is not that the correct true/false value cannot be chosen by the TM. > It is that both true/false values are the wrong answer. > > In my case this issue is solved. H(P,P) always aborts its input never > returning any value to its input. And get the WRONG ANSWER.
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2021-07-15 01:44 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <0fc8b001-8881-4872-86a5-191e18bd2af6n@googlegroups.com> |
| In reply to | #36323 |
On Thursday, 15 July 2021 at 04:12:32 UTC+1, olcott wrote: > On 7/14/2021 9:57 PM, Richard Damon wrote: > > When you provide the context of a TM/input pair then the brand new idea > that I created "incorrect question" is formed: > > When-so-ever a yes/no question has no correct answer from the set of > yes/no or a decision problem TM/input pair has has no final state > indicting a correct Boolean value then it is an error. > > Undecidability has always only been an error. > It is not that the correct true/false value cannot be chosen by the TM. > It is that both true/false values are the wrong answer. > H_Hat is constructed after H. There's always a right answer - H_Hat(H_Hat) either halts or it does not. But H always gets that answer wrong. > > In my case this issue is solved. H(P,P) always aborts its input never > returning any value to its input. > We seem to be going back to the "abort rather than return control" and maybe "the operating system contains a halt decider" ideas.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-15 09:17 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <i4SdndRj-7MT3m39nZ2dnUU7-QXNnZ2d@giganews.com> |
| In reply to | #36328 |
On 7/15/2021 3:44 AM, Malcolm McLean wrote: > On Thursday, 15 July 2021 at 04:12:32 UTC+1, olcott wrote: >> On 7/14/2021 9:57 PM, Richard Damon wrote: >> >> When you provide the context of a TM/input pair then the brand new idea >> that I created "incorrect question" is formed: >> >> When-so-ever a yes/no question has no correct answer from the set of >> yes/no or a decision problem TM/input pair has has no final state >> indicting a correct Boolean value then it is an error. >> >> Undecidability has always only been an error. >> It is not that the correct true/false value cannot be chosen by the TM. >> It is that both true/false values are the wrong answer. >> > H_Hat is constructed after H. Both H and P are static machine-code in a COFF object file. > There's always a right answer - When the question is what Boolean value can H correctly return to an input that does the opposite of what H decides it is as obvious as Hell that there is no correct answer to this specific question. When you change the question to: Does H P halt on its input you are not answering the actual question with its full context. > H_Hat(H_Hat) either halts or it does not. But H always gets that answer > wrong. Because the full context of the question proves that no Boolean value returned by H to an input that does the opposite of whatever H decides is a correct answer. When-so-ever zero elements of the solution set are a correct answer then the question itself is incorrect. >> >> In my case this issue is solved. H(P,P) always aborts its input never >> returning any value to its input. >> > We seem to be going back to the "abort rather than return control" and > maybe "the operating system contains a halt decider" ideas. > No H has ever returned any value to its input. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-07-15 21:04 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <87bl73tkc3.fsf@bsb.me.uk> |
| In reply to | #36332 |
olcott <NoOne@NoWhere.com> writes: > On 7/15/2021 3:44 AM, Malcolm McLean wrote: >> On Thursday, 15 July 2021 at 04:12:32 UTC+1, olcott wrote: >>> On 7/14/2021 9:57 PM, Richard Damon wrote: >>> >>> When you provide the context of a TM/input pair then the brand new idea >>> that I created "incorrect question" is formed: >>> >>> When-so-ever a yes/no question has no correct answer from the set of >>> yes/no or a decision problem TM/input pair has has no final state >>> indicting a correct Boolean value then it is an error. >>> >>> Undecidability has always only been an error. >>> It is not that the correct true/false value cannot be chosen by the TM. >>> It is that both true/false values are the wrong answer. >>> >> H_Hat is constructed after H. >> There's always a right answer - > > When the question is what Boolean value can H correctly return to an > input that does the opposite of what H decides it is as obvious as > Hell that there is no correct answer to this specific question. That's your question. It's not the halting problem "question". You gave us the correct answer to that question for your H^ (now called P) when you posted a trace showing that it halts. (And you'd also said so, using rather timid language, before that as well.) > When you change the question to: Does H P halt on its input you are > not answering the actual question with its full context. You are, instead, asking the halting problem "question". This is a question that always has a correct yes/no answer, thought algorithm can determine which in every case. -- Ben.
[toc] | [prev] | [next] | [standalone]
Page 8 of 17 — ← Prev page 1 … 6 7 [8] 9 10 … 17 Next page →
Back to top | Article view | comp.theory
csiph-web