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 14 of 17 — ← Prev page 1 … 12 13 [14] 15 16 17 Next page →
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-07-06 13:07 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <877di3abnn.fsf@bsb.me.uk> |
| In reply to | #35792 |
olcott <NoOne@NoWhere.com> writes:
> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>> Try and get your double-talk around this:
>>>
>>> void P(u32 x)
>>> {
>>> u32 Input_Halts = H(x, x);
>>> if (Input_Halts)
>>> HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> P((u32)P);
>>> }
>>>
>>> Because the above computation must be aborted at some point or it
>>> never halts the above computation is a non-halting computation.
>>
>> It is a halting computation because it halts. The fact that P(P) halts
>> is not in dispute.
>>
>> Nor is it a matter of dispute that your POOH decider, H, returns H(P,P)
>> == 0 and so P(P) is a non-POOH computation. The only dispute is that
>> you think someone might be interested in the POOH problem.
>> (For obvious reasons, you resist giving the property you claim H is
>> deciding a proper name. I'm not entirely sold on "PO Other Halting" but
>> you won't suggest a better alternative.)
>
> On the basis that we know that every UTM(P,I) never halts defines the
> exact same set of computations that must be aborted by a simulating
> halt decider which defines the exact same set of computations P(I)
> that never halt we can know that any input to a simulating halt
> decider that never halts unless its simulation is aborted is a
> non-halting computation.
That's a lot of waffle. The computations for which a halt decider
should return 0 are those that don't halt. P(P) halts, so H(P,P) == 0
is wrong.
Any decision problem for which 0 is the correct answer for P(P) is
something other than the halting problem. I'm calling it the PO
"Other-Halting" problem until a better name is suggested.
> Because the x86 execution trace of P on input P...
... shows that P(P) halts, we know that H(P,P) == 0 is wrong.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-06 08:27 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <2YqdnR0Nc9Ssx3n9nZ2dnUU7-SnNnZ2d@giganews.com> |
| In reply to | #35799 |
On 7/6/2021 7:07 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>
>>>> Try and get your double-talk around this:
>>>>
>>>> void P(u32 x)
>>>> {
>>>> u32 Input_Halts = H(x, x);
>>>> if (Input_Halts)
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> P((u32)P);
>>>> }
>>>>
>>>> Because the above computation must be aborted at some point or it
>>>> never halts the above computation is a non-halting computation.
>>>
>>> It is a halting computation because it halts. The fact that P(P) halts
>>> is not in dispute.
>>>
>>> Nor is it a matter of dispute that your POOH decider, H, returns H(P,P)
>>> == 0 and so P(P) is a non-POOH computation. The only dispute is that
>>> you think someone might be interested in the POOH problem.
>>> (For obvious reasons, you resist giving the property you claim H is
>>> deciding a proper name. I'm not entirely sold on "PO Other Halting" but
>>> you won't suggest a better alternative.)
>>
>> On the basis that we know that every UTM(P,I) never halts defines the
>> exact same set of computations that must be aborted by a simulating
>> halt decider which defines the exact same set of computations P(I)
>> that never halt we can know that any input to a simulating halt
>> decider that never halts unless its simulation is aborted is a
>> non-halting computation.
>
> That's a lot of waffle. The computations for which a halt decider
> should return 0 are those that don't halt. P(P) halts, so H(P,P) == 0
> is wrong.
>
The is a lot of double-talk. I provided a sequence of correct deductions
and you only provided your opinion that you don't like it.
> Any decision problem for which 0 is the correct answer for P(P) is
> something other than the halting problem. I'm calling it the PO
> "Other-Halting" problem until a better name is suggested.
>
>> Because the x86 execution trace of P on input P...
>
> ... shows that P(P) halts, we know that H(P,P) == 0 is wrong.
>
The criteria for non-halting is impossibly incorrect. If we have the DNA
of a black cat and this black cat barks we still have a black cat.
--
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-06 07:42 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <aa70a95a-c8eb-495a-9563-c6716ab34f7bn@googlegroups.com> |
| In reply to | #35802 |
On Tuesday, 6 July 2021 at 21:27:20 UTC+8, olcott wrote:
> On 7/6/2021 7:07 AM, Ben Bacarisse wrote:
> > olcott <No...@NoWhere.com> writes:
> >
> >> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
> >>> olcott <No...@NoWhere.com> writes:
> >
> >>>> Try and get your double-talk around this:
> >>>>
> >>>> void P(u32 x)
> >>>> {
> >>>> u32 Input_Halts = H(x, x);
> >>>> if (Input_Halts)
> >>>> HERE: goto HERE;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> P((u32)P);
> >>>> }
> >>>>
> >>>> Because the above computation must be aborted at some point or it
> >>>> never halts the above computation is a non-halting computation.
> >>>
> >>> It is a halting computation because it halts. The fact that P(P) halts
> >>> is not in dispute.
> >>>
> >>> Nor is it a matter of dispute that your POOH decider, H, returns H(P,P)
> >>> == 0 and so P(P) is a non-POOH computation. The only dispute is that
> >>> you think someone might be interested in the POOH problem.
> >>> (For obvious reasons, you resist giving the property you claim H is
> >>> deciding a proper name. I'm not entirely sold on "PO Other Halting" but
> >>> you won't suggest a better alternative.)
> >>
> >> On the basis that we know that every UTM(P,I) never halts defines the
> >> exact same set of computations that must be aborted by a simulating
> >> halt decider which defines the exact same set of computations P(I)
> >> that never halt we can know that any input to a simulating halt
> >> decider that never halts unless its simulation is aborted is a
> >> non-halting computation.
> >
> > That's a lot of waffle. The computations for which a halt decider
> > should return 0 are those that don't halt. P(P) halts, so H(P,P) == 0
> > is wrong.
> >
> The is a lot of double-talk. I provided a sequence of correct deductions
> and you only provided your opinion that you don't like it.
That is simply all it is, not an opinion (IMO), very simple.
You made a simple thing very complicated for yourself, by redefining the HP,
and build an 'x86utm' OS because you like it? or what?
> > Any decision problem for which 0 is the correct answer for P(P) is
> > something other than the halting problem. I'm calling it the PO
> > "Other-Halting" problem until a better name is suggested.
> >
> >> Because the x86 execution trace of P on input P...
> >
> > ... shows that P(P) halts, we know that H(P,P) == 0 is wrong.
> >
> The criteria for non-halting is impossibly incorrect. If we have the DNA
> of a black cat and this black cat barks we still have a black cat.
Simple fact is that H can not pass a real test.
There is no need for any real software engineer to talk about your reasoning
and implement.
> --
> Copyright 2021 Pete Olcott
>
> "Great spirits have always encountered violent opposition from mediocre
> minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-06 10:26 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <TM-dna0r7JqM63n9nZ2dnUU7-enNnZ2d@giganews.com> |
| In reply to | #35803 |
On 7/6/2021 9:42 AM, wij wrote:
> On Tuesday, 6 July 2021 at 21:27:20 UTC+8, olcott wrote:
>> On 7/6/2021 7:07 AM, Ben Bacarisse wrote:
>>> olcott <No...@NoWhere.com> writes:
>>>
>>>> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
>>>>> olcott <No...@NoWhere.com> writes:
>>>
>>>>>> Try and get your double-talk around this:
>>>>>>
>>>>>> void P(u32 x)
>>>>>> {
>>>>>> u32 Input_Halts = H(x, x);
>>>>>> if (Input_Halts)
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> P((u32)P);
>>>>>> }
>>>>>>
>>>>>> Because the above computation must be aborted at some point or it
>>>>>> never halts the above computation is a non-halting computation.
>>>>>
>>>>> It is a halting computation because it halts. The fact that P(P) halts
>>>>> is not in dispute.
>>>>>
>>>>> Nor is it a matter of dispute that your POOH decider, H, returns H(P,P)
>>>>> == 0 and so P(P) is a non-POOH computation. The only dispute is that
>>>>> you think someone might be interested in the POOH problem.
>>>>> (For obvious reasons, you resist giving the property you claim H is
>>>>> deciding a proper name. I'm not entirely sold on "PO Other Halting" but
>>>>> you won't suggest a better alternative.)
>>>>
>>>> On the basis that we know that every UTM(P,I) never halts defines the
>>>> exact same set of computations that must be aborted by a simulating
>>>> halt decider which defines the exact same set of computations P(I)
>>>> that never halt we can know that any input to a simulating halt
>>>> decider that never halts unless its simulation is aborted is a
>>>> non-halting computation.
>>>
>>> That's a lot of waffle. The computations for which a halt decider
>>> should return 0 are those that don't halt. P(P) halts, so H(P,P) == 0
>>> is wrong.
>>>
>> The is a lot of double-talk. I provided a sequence of correct deductions
>> and you only provided your opinion that you don't like it.
>
> That is simply all it is, not an opinion (IMO), very simple.
> You made a simple thing very complicated for yourself, by redefining the HP,
> and build an 'x86utm' OS because you like it? or what?
>
>>> Any decision problem for which 0 is the correct answer for P(P) is
>>> something other than the halting problem. I'm calling it the PO
>>> "Other-Halting" problem until a better name is suggested.
>>>
>>>> Because the x86 execution trace of P on input P...
>>>
>>> ... shows that P(P) halts, we know that H(P,P) == 0 is wrong.
>>>
>> The criteria for non-halting is impossibly incorrect. If we have the DNA
>> of a black cat and this black cat barks we still have a black cat.
>
> Simple fact is that H can not pass a real test.
> There is no need for any real software engineer to talk about your reasoning
> and implement.
The criterion measure of every Turing Machine Description ⟨P⟩ of Turing
machine P that would never halt on its input I <is> the exact same set
as the set of simulations (P,I) that must be aborted to prevent their
infinite simulation <is> the exact same set as Turing machines that do
not halt on their input P(I) cannot be circumvented or bypassed.
There is no case where a black cat is not a cat that is black.
>
>> --
>> Copyright 2021 Pete Olcott
>>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
+
--
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-06 22:02 -0400 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <VW7FI.6175$dp5.4577@fx48.iad> |
| In reply to | #35806 |
On 7/6/21 11:26 AM, olcott wrote: > The criterion measure of every Turing Machine Description ⟨P⟩ of Turing > machine P that would never halt on its input I <is> the exact same set > as the set of simulations (P,I) that must be aborted to prevent their > infinite simulation <is> the exact same set as Turing machines that do > not halt on their input P(I) cannot be circumvented or bypassed. > > There is no case where a black cat is not a cat that is black. > Yes, and Linz H^ is NOT one of those machines that will never halt unless its simulator abort it. You get confused by the fact that as part of its logic, with your H, that P will simulate a COPY of itself, and abort that COPY. The original is NOT aborted when H^ is run as the actual machine (Which is what really counts). In fact, there isn't anything that CAN abort H^ when run as the actual machine, but it still Halts. >
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-07-07 02:56 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <87zguy7upn.fsf@bsb.me.uk> |
| In reply to | #35802 |
olcott <NoOne@NoWhere.com> writes:
> On 7/6/2021 7:07 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>> Try and get your double-talk around this:
>>>>>
>>>>> void P(u32 x)
>>>>> {
>>>>> u32 Input_Halts = H(x, x);
>>>>> if (Input_Halts)
>>>>> HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> P((u32)P);
>>>>> }
>>>>>
>>>>> Because the above computation must be aborted at some point or it
>>>>> never halts the above computation is a non-halting computation.
>>>>
>>>> It is a halting computation because it halts. The fact that P(P) halts
>>>> is not in dispute.
>>>>
>>>> Nor is it a matter of dispute that your POOH decider, H, returns H(P,P)
>>>> == 0 and so P(P) is a non-POOH computation. The only dispute is that
>>>> you think someone might be interested in the POOH problem.
>>>> (For obvious reasons, you resist giving the property you claim H is
>>>> deciding a proper name. I'm not entirely sold on "PO Other Halting" but
>>>> you won't suggest a better alternative.)
>>>
>>> On the basis that we know that every UTM(P,I) never halts defines the
>>> exact same set of computations that must be aborted by a simulating
>>> halt decider which defines the exact same set of computations P(I)
>>> that never halt we can know that any input to a simulating halt
>>> decider that never halts unless its simulation is aborted is a
>>> non-halting computation.
>>
>> That's a lot of waffle. The computations for which a halt decider
>> should return 0 are those that don't halt. P(P) halts, so H(P,P) == 0
>> is wrong.
>
> The is a lot of double-talk. I provided a sequence of correct
> deductions and you only provided your opinion that you don't like it.
That P(P) halts and so H(P,P) == 0 is wrong is not "my opinion".
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-07-06 21:59 -0400 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <nU7FI.6174$dp5.5578@fx48.iad> |
| In reply to | #35802 |
On 7/6/21 9:27 AM, olcott wrote: > On 7/6/2021 7:07 AM, Ben Bacarisse wrote: >> >> That's a lot of waffle. The computations for which a halt decider >> should return 0 are those that don't halt. P(P) halts, so H(P,P) == 0 >> is wrong. >> > > The is a lot of double-talk. I provided a sequence of correct deductions > and you only provided your opinion that you don't like it. Except the double-talk is from you, since your 'sequence of correct deductions' is provably unsound since you start with the assumption that H will NEVER abort the simulation, and then you use that results for an H that does abort. Since these two cases have DIFFERENT P's the result absolutely doesn't apply. The Logic is Unsound, and thus wrong. > >> Any decision problem for which 0 is the correct answer for P(P) is >> something other than the halting problem. I'm calling it the PO >> "Other-Halting" problem until a better name is suggested. >> >>> Because the x86 execution trace of P on input P... >> >> ... shows that P(P) halts, we know that H(P,P) == 0 is wrong. >> > > The criteria for non-halting is impossibly incorrect. If we have the DNA > of a black cat and this black cat barks we still have a black cat. > Yes, it is impossible for it to be correct, since a counter example has been provided. Linz H^, for your H, IS a Halting computation, but H says it is non-Halting. It seems someone has confused you as to the rules of logic, or contaminated your samples. The Halting computation is definiitely not Non-Halting.
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-06 21:18 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <20210706211814.00004067@reddwarf.jmc> |
| In reply to | #35792 |
On Mon, 5 Jul 2021 23:15:06 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
> > olcott <NoOne@NoWhere.com> writes:
> >
> >> On 7/5/2021 4:34 PM, Ben Bacarisse wrote:
> >>> For anyone interested, here's the answer to the question posed in
> >>> the subject line: How do we know that H(P,P)==0 is correct?
> >>>
> >>> We know that H(M,I) == 0 (false) is correct if, and only if, M(I)
> >>> is not a halting (finite) computation.
> >>>
> >>> But PO rejects the very definition of a halting decider: a TM that
> >>> accepts exactly those strings that represent finite computations,
> >>> and rejects all others.
> >>>
> >>> Instead, a PO "Other-Halting" decider also rejects some strings
> >>> that represent finite computations, specifically P(P) where P is
> >>> hat(H), a function defined in terms of H like this:
> >>> def hat(h):
> >>> def p(x):
> >>> if h(x, x):
> >>> while True: pass
> >>> return p
> >>>
> >>> For a POOH decider, H(hat(H), hat(H)) = False is correct, despite
> >>> hat(H)(hat(H)) being a halting computation. No one except PO is
> >>> interested in the POOH problem.
> >>>
> >>> On the other hand, everyone is interested in halting, but the
> >>> computation D(hat(D), hat(D)) shows that no D computes the halting
> >>> function.
> >>
> >> Try and get your double-talk around this:
> >>
> >> void P(u32 x)
> >> {
> >> u32 Input_Halts = H(x, x);
> >> if (Input_Halts)
> >> HERE: goto HERE;
> >> }
> >>
> >> int main()
> >> {
> >> P((u32)P);
> >> }
> >>
> >> Because the above computation must be aborted at some point or it
> >> never halts the above computation is a non-halting computation.
> >
> > It is a halting computation because it halts. The fact that P(P)
> > halts is not in dispute.
> >
> > Nor is it a matter of dispute that your POOH decider, H, returns
> > H(P,P) == 0 and so P(P) is a non-POOH computation. The only
> > dispute is that you think someone might be interested in the POOH
> > problem.
> >
> > (For obvious reasons, you resist giving the property you claim H is
> > deciding a proper name. I'm not entirely sold on "PO Other
> > Halting" but you won't suggest a better alternative.)
> >
>
> On the basis that we know that every UTM(P,I) never halts defines the
> exact same set of computations that must be aborted by a simulating
> halt decider which defines the exact same set of computations P(I)
> that never halt we can know that any input to a simulating halt
> decider that never halts unless its simulation is aborted is a
> non-halting computation.
>
> Because we know that a simulating halt decider only simulates its
> input until after it has made its halt status decision we can know
> that H can ignore its own address range in its execution traces.
>
> Because the x86 execution trace of P on input P provides no possible
> escape from infinitely nested simulation and we can ignore the
> execution trace of H then we can know that H must abort its
> simulation of P on the basis of the sixteen lines of P:
>
> _P()
> [00000b25](01) 55 push ebp
> [00000b26](02) 8bec mov ebp,esp
> [00000b28](01) 51 push ecx
> [00000b29](03) 8b4508 mov eax,[ebp+08]
> [00000b2c](01) 50 push eax
> [00000b2d](03) 8b4d08 mov ecx,[ebp+08]
> [00000b30](01) 51 push ecx
> [00000b31](05) e81ffeffff call 00000955 // call H
>
> Begin Local Halt Decider Simulation at Machine Address:b25
> ...[00000b25][002116fe][00211702](01) 55 push ebp
> // P1 ...[00000b26][002116fe][00211702](02) 8bec mov
> ebp,esp ...[00000b28][002116fa][002016ce](01) 51 push
> ecx ...[00000b29][002116fa][002016ce](03) 8b4508 mov
> eax,[ebp+08] ...[00000b2c][002116f6][00000b25](01) 50
> push eax ...[00000b2d][002116f6][00000b25](03) 8b4d08 mov
> ecx,[ebp+08] ...[00000b30][002116f2][00000b25](01) 51
> push ecx ...[00000b31][002116ee][00000b36](05) e81ffeffff call
> 00000955 // H1 ...[00000b25][0025c126][0025c12a](01) 55
> push ebp // P2 ...[00000b26][0025c126][0025c12a](02) 8bec
> mov ebp,esp ...[00000b28][0025c122][0024c0f6](01) 51
> push ecx ...[00000b29][0025c122][0024c0f6](03) 8b4508
> mov eax,[ebp+08] ...[00000b2c][0025c11e][00000b25](01) 50
> push eax ...[00000b2d][0025c11e][00000b25](03) 8b4d08 mov
> ecx,[ebp+08] ...[00000b30][0025c11a][00000b25](01) 51
> push ecx ...[00000b31][0025c116][00000b36](05) e81ffeffff call
> 00000955 // H2 Local Halt Decider: Infinite Recursion Detected
> Simulation Stopped
But this case is trivial and uninteresting: your decider needs to
analyse branching logic predicated on arbitrary input to be
non-trivial and interesting. You've still got nothing of value to show.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-06 15:41 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <FIqdnaoDnft4Inn9nZ2dnUU7-UPNnZ2d@giganews.com> |
| In reply to | #35815 |
On 7/6/2021 3:18 PM, Mr Flibble wrote:
> On Mon, 5 Jul 2021 23:15:06 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 7/5/2021 4:34 PM, Ben Bacarisse wrote:
>>>>> For anyone interested, here's the answer to the question posed in
>>>>> the subject line: How do we know that H(P,P)==0 is correct?
>>>>>
>>>>> We know that H(M,I) == 0 (false) is correct if, and only if, M(I)
>>>>> is not a halting (finite) computation.
>>>>>
>>>>> But PO rejects the very definition of a halting decider: a TM that
>>>>> accepts exactly those strings that represent finite computations,
>>>>> and rejects all others.
>>>>>
>>>>> Instead, a PO "Other-Halting" decider also rejects some strings
>>>>> that represent finite computations, specifically P(P) where P is
>>>>> hat(H), a function defined in terms of H like this:
>>>>> def hat(h):
>>>>> def p(x):
>>>>> if h(x, x):
>>>>> while True: pass
>>>>> return p
>>>>>
>>>>> For a POOH decider, H(hat(H), hat(H)) = False is correct, despite
>>>>> hat(H)(hat(H)) being a halting computation. No one except PO is
>>>>> interested in the POOH problem.
>>>>>
>>>>> On the other hand, everyone is interested in halting, but the
>>>>> computation D(hat(D), hat(D)) shows that no D computes the halting
>>>>> function.
>>>>
>>>> Try and get your double-talk around this:
>>>>
>>>> void P(u32 x)
>>>> {
>>>> u32 Input_Halts = H(x, x);
>>>> if (Input_Halts)
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> P((u32)P);
>>>> }
>>>>
>>>> Because the above computation must be aborted at some point or it
>>>> never halts the above computation is a non-halting computation.
>>>
>>> It is a halting computation because it halts. The fact that P(P)
>>> halts is not in dispute.
>>>
>>> Nor is it a matter of dispute that your POOH decider, H, returns
>>> H(P,P) == 0 and so P(P) is a non-POOH computation. The only
>>> dispute is that you think someone might be interested in the POOH
>>> problem.
>>>
>>> (For obvious reasons, you resist giving the property you claim H is
>>> deciding a proper name. I'm not entirely sold on "PO Other
>>> Halting" but you won't suggest a better alternative.)
>>>
>>
>> On the basis that we know that every UTM(P,I) never halts defines the
>> exact same set of computations that must be aborted by a simulating
>> halt decider which defines the exact same set of computations P(I)
>> that never halt we can know that any input to a simulating halt
>> decider that never halts unless its simulation is aborted is a
>> non-halting computation.
>>
>> Because we know that a simulating halt decider only simulates its
>> input until after it has made its halt status decision we can know
>> that H can ignore its own address range in its execution traces.
>>
>> Because the x86 execution trace of P on input P provides no possible
>> escape from infinitely nested simulation and we can ignore the
>> execution trace of H then we can know that H must abort its
>> simulation of P on the basis of the sixteen lines of P:
>>
>> _P()
>> [00000b25](01) 55 push ebp
>> [00000b26](02) 8bec mov ebp,esp
>> [00000b28](01) 51 push ecx
>> [00000b29](03) 8b4508 mov eax,[ebp+08]
>> [00000b2c](01) 50 push eax
>> [00000b2d](03) 8b4d08 mov ecx,[ebp+08]
>> [00000b30](01) 51 push ecx
>> [00000b31](05) e81ffeffff call 00000955 // call H
>>
>> Begin Local Halt Decider Simulation at Machine Address:b25
>> ...[00000b25][002116fe][00211702](01) 55 push ebp
>> // P1 ...[00000b26][002116fe][00211702](02) 8bec mov
>> ebp,esp ...[00000b28][002116fa][002016ce](01) 51 push
>> ecx ...[00000b29][002116fa][002016ce](03) 8b4508 mov
>> eax,[ebp+08] ...[00000b2c][002116f6][00000b25](01) 50
>> push eax ...[00000b2d][002116f6][00000b25](03) 8b4d08 mov
>> ecx,[ebp+08] ...[00000b30][002116f2][00000b25](01) 51
>> push ecx ...[00000b31][002116ee][00000b36](05) e81ffeffff call
>> 00000955 // H1 ...[00000b25][0025c126][0025c12a](01) 55
>> push ebp // P2 ...[00000b26][0025c126][0025c12a](02) 8bec
>> mov ebp,esp ...[00000b28][0025c122][0024c0f6](01) 51
>> push ecx ...[00000b29][0025c122][0024c0f6](03) 8b4508
>> mov eax,[ebp+08] ...[00000b2c][0025c11e][00000b25](01) 50
>> push eax ...[00000b2d][0025c11e][00000b25](03) 8b4d08 mov
>> ecx,[ebp+08] ...[00000b30][0025c11a][00000b25](01) 51
>> push ecx ...[00000b31][0025c116][00000b36](05) e81ffeffff call
>> 00000955 // H2 Local Halt Decider: Infinite Recursion Detected
>> Simulation Stopped
>
> But this case is trivial and uninteresting: your decider needs to
> analyse branching logic predicated on arbitrary input to be
> non-trivial and interesting. You've still got nothing of value to show.
>
> /Flibble
>
>
Once people comprehend that my halting criteria eliminates the
pathological self-reference(Olcott 2004) of the halting problem proof
counter-examples they will understand that the halting problem is not
undecidable. Then teams of hundreds of software developers can handle
details such as branching logic.
The reason that my C code analyzes x86 code is that x86 code provides a
complete directed graph of all control flow.
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 | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-06 23:18 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <20210706231852.0000320a@reddwarf.jmc> |
| In reply to | #35816 |
On Tue, 6 Jul 2021 15:41:09 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/6/2021 3:18 PM, Mr Flibble wrote:
> > On Mon, 5 Jul 2021 23:15:06 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
> >>> olcott <NoOne@NoWhere.com> writes:
> >>>
> >>>> On 7/5/2021 4:34 PM, Ben Bacarisse wrote:
> >>>>> For anyone interested, here's the answer to the question posed
> >>>>> in the subject line: How do we know that H(P,P)==0 is correct?
> >>>>>
> >>>>> We know that H(M,I) == 0 (false) is correct if, and only if,
> >>>>> M(I) is not a halting (finite) computation.
> >>>>>
> >>>>> But PO rejects the very definition of a halting decider: a TM
> >>>>> that accepts exactly those strings that represent finite
> >>>>> computations, and rejects all others.
> >>>>>
> >>>>> Instead, a PO "Other-Halting" decider also rejects some strings
> >>>>> that represent finite computations, specifically P(P) where P is
> >>>>> hat(H), a function defined in terms of H like this:
> >>>>> def hat(h):
> >>>>> def p(x):
> >>>>> if h(x, x):
> >>>>> while True: pass
> >>>>> return p
> >>>>>
> >>>>> For a POOH decider, H(hat(H), hat(H)) = False is correct,
> >>>>> despite hat(H)(hat(H)) being a halting computation. No one
> >>>>> except PO is interested in the POOH problem.
> >>>>>
> >>>>> On the other hand, everyone is interested in halting, but the
> >>>>> computation D(hat(D), hat(D)) shows that no D computes the
> >>>>> halting function.
> >>>>
> >>>> Try and get your double-talk around this:
> >>>>
> >>>> void P(u32 x)
> >>>> {
> >>>> u32 Input_Halts = H(x, x);
> >>>> if (Input_Halts)
> >>>> HERE: goto HERE;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> P((u32)P);
> >>>> }
> >>>>
> >>>> Because the above computation must be aborted at some point or it
> >>>> never halts the above computation is a non-halting computation.
> >>>
> >>> It is a halting computation because it halts. The fact that P(P)
> >>> halts is not in dispute.
> >>>
> >>> Nor is it a matter of dispute that your POOH decider, H, returns
> >>> H(P,P) == 0 and so P(P) is a non-POOH computation. The only
> >>> dispute is that you think someone might be interested in the POOH
> >>> problem.
> >>>
> >>> (For obvious reasons, you resist giving the property you claim H
> >>> is deciding a proper name. I'm not entirely sold on "PO Other
> >>> Halting" but you won't suggest a better alternative.)
> >>>
> >>
> >> On the basis that we know that every UTM(P,I) never halts defines
> >> the exact same set of computations that must be aborted by a
> >> simulating halt decider which defines the exact same set of
> >> computations P(I) that never halt we can know that any input to a
> >> simulating halt decider that never halts unless its simulation is
> >> aborted is a non-halting computation.
> >>
> >> Because we know that a simulating halt decider only simulates its
> >> input until after it has made its halt status decision we can know
> >> that H can ignore its own address range in its execution traces.
> >>
> >> Because the x86 execution trace of P on input P provides no
> >> possible escape from infinitely nested simulation and we can
> >> ignore the execution trace of H then we can know that H must abort
> >> its simulation of P on the basis of the sixteen lines of P:
> >>
> >> _P()
> >> [00000b25](01) 55 push ebp
> >> [00000b26](02) 8bec mov ebp,esp
> >> [00000b28](01) 51 push ecx
> >> [00000b29](03) 8b4508 mov eax,[ebp+08]
> >> [00000b2c](01) 50 push eax
> >> [00000b2d](03) 8b4d08 mov ecx,[ebp+08]
> >> [00000b30](01) 51 push ecx
> >> [00000b31](05) e81ffeffff call 00000955 // call H
> >>
> >> Begin Local Halt Decider Simulation at Machine Address:b25
> >> ...[00000b25][002116fe][00211702](01) 55 push ebp
> >> // P1 ...[00000b26][002116fe][00211702](02) 8bec mov
> >> ebp,esp ...[00000b28][002116fa][002016ce](01) 51 push
> >> ecx ...[00000b29][002116fa][002016ce](03) 8b4508 mov
> >> eax,[ebp+08] ...[00000b2c][002116f6][00000b25](01) 50
> >> push eax ...[00000b2d][002116f6][00000b25](03) 8b4d08 mov
> >> ecx,[ebp+08] ...[00000b30][002116f2][00000b25](01) 51
> >> push ecx ...[00000b31][002116ee][00000b36](05) e81ffeffff
> >> call 00000955 // H1 ...[00000b25][0025c126][0025c12a](01) 55
> >> push ebp // P2 ...[00000b26][0025c126][0025c12a](02) 8bec
> >> mov ebp,esp ...[00000b28][0025c122][0024c0f6](01) 51
> >> push ecx ...[00000b29][0025c122][0024c0f6](03) 8b4508
> >> mov eax,[ebp+08] ...[00000b2c][0025c11e][00000b25](01) 50
> >> push eax ...[00000b2d][0025c11e][00000b25](03) 8b4d08
> >> mov ecx,[ebp+08] ...[00000b30][0025c11a][00000b25](01) 51
> >> push ecx ...[00000b31][0025c116][00000b36](05) e81ffeffff
> >> call 00000955 // H2 Local Halt Decider: Infinite Recursion
> >> Detected Simulation Stopped
> >
> > But this case is trivial and uninteresting: your decider needs to
> > analyse branching logic predicated on arbitrary input to be
> > non-trivial and interesting. You've still got nothing of value to
> > show.
> >
> > /Flibble
> >
> >
>
> Once people comprehend that my halting criteria eliminates the
> pathological self-reference(Olcott 2004) of the halting problem proof
> counter-examples they will understand that the halting problem is not
> undecidable. Then teams of hundreds of software developers can handle
> details such as branching logic.
>
> The reason that my C code analyzes x86 code is that x86 code provides
> a complete directed graph of all control flow.
Nonsense:
mov eax,[ebp+08]
the memory at the address [ebp+08] might be
mapped to an I/O device so you don't know a priori what value it will
have.
More nonsense is of course that you have yet to show an example which
does involve control flow (with branching logic) and even if you did you
haven't responded to people posting non-trivial control flow examples.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-06 16:13 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <550145e0-e865-46b8-b52f-f0cff8be0731n@googlegroups.com> |
| In reply to | #35818 |
On Tuesday, July 6, 2021 at 6:18:55 PM UTC-4, Mr Flibble wrote:
> On Tue, 6 Jul 2021 15:41:09 -0500
> olcott <No...@NoWhere.com> wrote:
>
> > On 7/6/2021 3:18 PM, Mr Flibble wrote:
> > > On Mon, 5 Jul 2021 23:15:06 -0500
> > > olcott <No...@NoWhere.com> wrote:
> > >
> > >> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
> > >>> olcott <No...@NoWhere.com> writes:
> > >>>
> > >>>> On 7/5/2021 4:34 PM, Ben Bacarisse wrote:
> > >>>>> For anyone interested, here's the answer to the question posed
> > >>>>> in the subject line: How do we know that H(P,P)==0 is correct?
> > >>>>>
> > >>>>> We know that H(M,I) == 0 (false) is correct if, and only if,
> > >>>>> M(I) is not a halting (finite) computation.
> > >>>>>
> > >>>>> But PO rejects the very definition of a halting decider: a TM
> > >>>>> that accepts exactly those strings that represent finite
> > >>>>> computations, and rejects all others.
> > >>>>>
> > >>>>> Instead, a PO "Other-Halting" decider also rejects some strings
> > >>>>> that represent finite computations, specifically P(P) where P is
> > >>>>> hat(H), a function defined in terms of H like this:
> > >>>>> def hat(h):
> > >>>>> def p(x):
> > >>>>> if h(x, x):
> > >>>>> while True: pass
> > >>>>> return p
> > >>>>>
> > >>>>> For a POOH decider, H(hat(H), hat(H)) = False is correct,
> > >>>>> despite hat(H)(hat(H)) being a halting computation. No one
> > >>>>> except PO is interested in the POOH problem.
> > >>>>>
> > >>>>> On the other hand, everyone is interested in halting, but the
> > >>>>> computation D(hat(D), hat(D)) shows that no D computes the
> > >>>>> halting function.
> > >>>>
> > >>>> Try and get your double-talk around this:
> > >>>>
> > >>>> void P(u32 x)
> > >>>> {
> > >>>> u32 Input_Halts = H(x, x);
> > >>>> if (Input_Halts)
> > >>>> HERE: goto HERE;
> > >>>> }
> > >>>>
> > >>>> int main()
> > >>>> {
> > >>>> P((u32)P);
> > >>>> }
> > >>>>
> > >>>> Because the above computation must be aborted at some point or it
> > >>>> never halts the above computation is a non-halting computation.
> > >>>
> > >>> It is a halting computation because it halts. The fact that P(P)
> > >>> halts is not in dispute.
> > >>>
> > >>> Nor is it a matter of dispute that your POOH decider, H, returns
> > >>> H(P,P) == 0 and so P(P) is a non-POOH computation. The only
> > >>> dispute is that you think someone might be interested in the POOH
> > >>> problem.
> > >>>
> > >>> (For obvious reasons, you resist giving the property you claim H
> > >>> is deciding a proper name. I'm not entirely sold on "PO Other
> > >>> Halting" but you won't suggest a better alternative.)
> > >>>
> > >>
> > >> On the basis that we know that every UTM(P,I) never halts defines
> > >> the exact same set of computations that must be aborted by a
> > >> simulating halt decider which defines the exact same set of
> > >> computations P(I) that never halt we can know that any input to a
> > >> simulating halt decider that never halts unless its simulation is
> > >> aborted is a non-halting computation.
> > >>
> > >> Because we know that a simulating halt decider only simulates its
> > >> input until after it has made its halt status decision we can know
> > >> that H can ignore its own address range in its execution traces.
> > >>
> > >> Because the x86 execution trace of P on input P provides no
> > >> possible escape from infinitely nested simulation and we can
> > >> ignore the execution trace of H then we can know that H must abort
> > >> its simulation of P on the basis of the sixteen lines of P:
> > >>
> > >> _P()
> > >> [00000b25](01) 55 push ebp
> > >> [00000b26](02) 8bec mov ebp,esp
> > >> [00000b28](01) 51 push ecx
> > >> [00000b29](03) 8b4508 mov eax,[ebp+08]
> > >> [00000b2c](01) 50 push eax
> > >> [00000b2d](03) 8b4d08 mov ecx,[ebp+08]
> > >> [00000b30](01) 51 push ecx
> > >> [00000b31](05) e81ffeffff call 00000955 // call H
> > >>
> > >> Begin Local Halt Decider Simulation at Machine Address:b25
> > >> ...[00000b25][002116fe][00211702](01) 55 push ebp
> > >> // P1 ...[00000b26][002116fe][00211702](02) 8bec mov
> > >> ebp,esp ...[00000b28][002116fa][002016ce](01) 51 push
> > >> ecx ...[00000b29][002116fa][002016ce](03) 8b4508 mov
> > >> eax,[ebp+08] ...[00000b2c][002116f6][00000b25](01) 50
> > >> push eax ...[00000b2d][002116f6][00000b25](03) 8b4d08 mov
> > >> ecx,[ebp+08] ...[00000b30][002116f2][00000b25](01) 51
> > >> push ecx ...[00000b31][002116ee][00000b36](05) e81ffeffff
> > >> call 00000955 // H1 ...[00000b25][0025c126][0025c12a](01) 55
> > >> push ebp // P2 ...[00000b26][0025c126][0025c12a](02) 8bec
> > >> mov ebp,esp ...[00000b28][0025c122][0024c0f6](01) 51
> > >> push ecx ...[00000b29][0025c122][0024c0f6](03) 8b4508
> > >> mov eax,[ebp+08] ...[00000b2c][0025c11e][00000b25](01) 50
> > >> push eax ...[00000b2d][0025c11e][00000b25](03) 8b4d08
> > >> mov ecx,[ebp+08] ...[00000b30][0025c11a][00000b25](01) 51
> > >> push ecx ...[00000b31][0025c116][00000b36](05) e81ffeffff
> > >> call 00000955 // H2 Local Halt Decider: Infinite Recursion
> > >> Detected Simulation Stopped
> > >
> > > But this case is trivial and uninteresting: your decider needs to
> > > analyse branching logic predicated on arbitrary input to be
> > > non-trivial and interesting. You've still got nothing of value to
> > > show.
> > >
> > > /Flibble
> > >
> > >
> >
> > Once people comprehend that my halting criteria eliminates the
> > pathological self-reference(Olcott 2004) of the halting problem proof
> > counter-examples they will understand that the halting problem is not
> > undecidable. Then teams of hundreds of software developers can handle
> > details such as branching logic.
> >
once people comprehend that my 1000 line pspace solver
shows P=coNP=PSPACE=#P=#Q=QSPACE
for modestly sized N then olcotts cycle detector
in a structure will be much less important.
this is a theory group nitwit. get the hell out.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-06 18:38 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <WaidnatEwqIMdHn9nZ2dnUU7-YudnZ2d@giganews.com> |
| In reply to | #35819 |
On 7/6/2021 6:13 PM, Daniel Pehoushek wrote:
> On Tuesday, July 6, 2021 at 6:18:55 PM UTC-4, Mr Flibble wrote:
>> On Tue, 6 Jul 2021 15:41:09 -0500
>> olcott <No...@NoWhere.com> wrote:
>>
>>> On 7/6/2021 3:18 PM, Mr Flibble wrote:
>>>> On Mon, 5 Jul 2021 23:15:06 -0500
>>>> olcott <No...@NoWhere.com> wrote:
>>>>
>>>>> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>
>>>>>>> On 7/5/2021 4:34 PM, Ben Bacarisse wrote:
>>>>>>>> For anyone interested, here's the answer to the question posed
>>>>>>>> in the subject line: How do we know that H(P,P)==0 is correct?
>>>>>>>>
>>>>>>>> We know that H(M,I) == 0 (false) is correct if, and only if,
>>>>>>>> M(I) is not a halting (finite) computation.
>>>>>>>>
>>>>>>>> But PO rejects the very definition of a halting decider: a TM
>>>>>>>> that accepts exactly those strings that represent finite
>>>>>>>> computations, and rejects all others.
>>>>>>>>
>>>>>>>> Instead, a PO "Other-Halting" decider also rejects some strings
>>>>>>>> that represent finite computations, specifically P(P) where P is
>>>>>>>> hat(H), a function defined in terms of H like this:
>>>>>>>> def hat(h):
>>>>>>>> def p(x):
>>>>>>>> if h(x, x):
>>>>>>>> while True: pass
>>>>>>>> return p
>>>>>>>>
>>>>>>>> For a POOH decider, H(hat(H), hat(H)) = False is correct,
>>>>>>>> despite hat(H)(hat(H)) being a halting computation. No one
>>>>>>>> except PO is interested in the POOH problem.
>>>>>>>>
>>>>>>>> On the other hand, everyone is interested in halting, but the
>>>>>>>> computation D(hat(D), hat(D)) shows that no D computes the
>>>>>>>> halting function.
>>>>>>>
>>>>>>> Try and get your double-talk around this:
>>>>>>>
>>>>>>> void P(u32 x)
>>>>>>> {
>>>>>>> u32 Input_Halts = H(x, x);
>>>>>>> if (Input_Halts)
>>>>>>> HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> P((u32)P);
>>>>>>> }
>>>>>>>
>>>>>>> Because the above computation must be aborted at some point or it
>>>>>>> never halts the above computation is a non-halting computation.
>>>>>>
>>>>>> It is a halting computation because it halts. The fact that P(P)
>>>>>> halts is not in dispute.
>>>>>>
>>>>>> Nor is it a matter of dispute that your POOH decider, H, returns
>>>>>> H(P,P) == 0 and so P(P) is a non-POOH computation. The only
>>>>>> dispute is that you think someone might be interested in the POOH
>>>>>> problem.
>>>>>>
>>>>>> (For obvious reasons, you resist giving the property you claim H
>>>>>> is deciding a proper name. I'm not entirely sold on "PO Other
>>>>>> Halting" but you won't suggest a better alternative.)
>>>>>>
>>>>>
>>>>> On the basis that we know that every UTM(P,I) never halts defines
>>>>> the exact same set of computations that must be aborted by a
>>>>> simulating halt decider which defines the exact same set of
>>>>> computations P(I) that never halt we can know that any input to a
>>>>> simulating halt decider that never halts unless its simulation is
>>>>> aborted is a non-halting computation.
>>>>>
>>>>> Because we know that a simulating halt decider only simulates its
>>>>> input until after it has made its halt status decision we can know
>>>>> that H can ignore its own address range in its execution traces.
>>>>>
>>>>> Because the x86 execution trace of P on input P provides no
>>>>> possible escape from infinitely nested simulation and we can
>>>>> ignore the execution trace of H then we can know that H must abort
>>>>> its simulation of P on the basis of the sixteen lines of P:
>>>>>
>>>>> _P()
>>>>> [00000b25](01) 55 push ebp
>>>>> [00000b26](02) 8bec mov ebp,esp
>>>>> [00000b28](01) 51 push ecx
>>>>> [00000b29](03) 8b4508 mov eax,[ebp+08]
>>>>> [00000b2c](01) 50 push eax
>>>>> [00000b2d](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [00000b30](01) 51 push ecx
>>>>> [00000b31](05) e81ffeffff call 00000955 // call H
>>>>>
>>>>> Begin Local Halt Decider Simulation at Machine Address:b25
>>>>> ...[00000b25][002116fe][00211702](01) 55 push ebp
>>>>> // P1 ...[00000b26][002116fe][00211702](02) 8bec mov
>>>>> ebp,esp ...[00000b28][002116fa][002016ce](01) 51 push
>>>>> ecx ...[00000b29][002116fa][002016ce](03) 8b4508 mov
>>>>> eax,[ebp+08] ...[00000b2c][002116f6][00000b25](01) 50
>>>>> push eax ...[00000b2d][002116f6][00000b25](03) 8b4d08 mov
>>>>> ecx,[ebp+08] ...[00000b30][002116f2][00000b25](01) 51
>>>>> push ecx ...[00000b31][002116ee][00000b36](05) e81ffeffff
>>>>> call 00000955 // H1 ...[00000b25][0025c126][0025c12a](01) 55
>>>>> push ebp // P2 ...[00000b26][0025c126][0025c12a](02) 8bec
>>>>> mov ebp,esp ...[00000b28][0025c122][0024c0f6](01) 51
>>>>> push ecx ...[00000b29][0025c122][0024c0f6](03) 8b4508
>>>>> mov eax,[ebp+08] ...[00000b2c][0025c11e][00000b25](01) 50
>>>>> push eax ...[00000b2d][0025c11e][00000b25](03) 8b4d08
>>>>> mov ecx,[ebp+08] ...[00000b30][0025c11a][00000b25](01) 51
>>>>> push ecx ...[00000b31][0025c116][00000b36](05) e81ffeffff
>>>>> call 00000955 // H2 Local Halt Decider: Infinite Recursion
>>>>> Detected Simulation Stopped
>>>>
>>>> But this case is trivial and uninteresting: your decider needs to
>>>> analyse branching logic predicated on arbitrary input to be
>>>> non-trivial and interesting. You've still got nothing of value to
>>>> show.
>>>>
>>>> /Flibble
>>>>
>>>>
>>>
>>> Once people comprehend that my halting criteria eliminates the
>>> pathological self-reference(Olcott 2004) of the halting problem proof
>>> counter-examples they will understand that the halting problem is not
>>> undecidable. Then teams of hundreds of software developers can handle
>>> details such as branching logic.
>>>
>
> once people comprehend that my 1000 line pspace solver
> shows P=coNP=PSPACE=#P=#Q=QSPACE
> for modestly sized N then olcotts cycle detector
> in a structure will be much less important.
> this is a theory group nitwit. get the hell out.
>
You are DV pretending to be someone else
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-06 18:44 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <UPidnbIpF7BLd3n9nZ2dnUU7-RfNnZ2d@giganews.com> |
| In reply to | #35819 |
On 7/6/2021 6:13 PM, Daniel Pehoushek wrote:
> On Tuesday, July 6, 2021 at 6:18:55 PM UTC-4, Mr Flibble wrote:
>> On Tue, 6 Jul 2021 15:41:09 -0500
>> olcott <No...@NoWhere.com> wrote:
>>
>>> On 7/6/2021 3:18 PM, Mr Flibble wrote:
>>>> On Mon, 5 Jul 2021 23:15:06 -0500
>>>> olcott <No...@NoWhere.com> wrote:
>>>>
>>>>> On 7/5/2021 6:15 PM, Ben Bacarisse wrote:
>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>
>>>>>>> On 7/5/2021 4:34 PM, Ben Bacarisse wrote:
>>>>>>>> For anyone interested, here's the answer to the question posed
>>>>>>>> in the subject line: How do we know that H(P,P)==0 is correct?
>>>>>>>>
>>>>>>>> We know that H(M,I) == 0 (false) is correct if, and only if,
>>>>>>>> M(I) is not a halting (finite) computation.
>>>>>>>>
>>>>>>>> But PO rejects the very definition of a halting decider: a TM
>>>>>>>> that accepts exactly those strings that represent finite
>>>>>>>> computations, and rejects all others.
>>>>>>>>
>>>>>>>> Instead, a PO "Other-Halting" decider also rejects some strings
>>>>>>>> that represent finite computations, specifically P(P) where P is
>>>>>>>> hat(H), a function defined in terms of H like this:
>>>>>>>> def hat(h):
>>>>>>>> def p(x):
>>>>>>>> if h(x, x):
>>>>>>>> while True: pass
>>>>>>>> return p
>>>>>>>>
>>>>>>>> For a POOH decider, H(hat(H), hat(H)) = False is correct,
>>>>>>>> despite hat(H)(hat(H)) being a halting computation. No one
>>>>>>>> except PO is interested in the POOH problem.
>>>>>>>>
>>>>>>>> On the other hand, everyone is interested in halting, but the
>>>>>>>> computation D(hat(D), hat(D)) shows that no D computes the
>>>>>>>> halting function.
>>>>>>>
>>>>>>> Try and get your double-talk around this:
>>>>>>>
>>>>>>> void P(u32 x)
>>>>>>> {
>>>>>>> u32 Input_Halts = H(x, x);
>>>>>>> if (Input_Halts)
>>>>>>> HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> P((u32)P);
>>>>>>> }
>>>>>>>
>>>>>>> Because the above computation must be aborted at some point or it
>>>>>>> never halts the above computation is a non-halting computation.
>>>>>>
>>>>>> It is a halting computation because it halts. The fact that P(P)
>>>>>> halts is not in dispute.
>>>>>>
>>>>>> Nor is it a matter of dispute that your POOH decider, H, returns
>>>>>> H(P,P) == 0 and so P(P) is a non-POOH computation. The only
>>>>>> dispute is that you think someone might be interested in the POOH
>>>>>> problem.
>>>>>>
>>>>>> (For obvious reasons, you resist giving the property you claim H
>>>>>> is deciding a proper name. I'm not entirely sold on "PO Other
>>>>>> Halting" but you won't suggest a better alternative.)
>>>>>>
>>>>>
>>>>> On the basis that we know that every UTM(P,I) never halts defines
>>>>> the exact same set of computations that must be aborted by a
>>>>> simulating halt decider which defines the exact same set of
>>>>> computations P(I) that never halt we can know that any input to a
>>>>> simulating halt decider that never halts unless its simulation is
>>>>> aborted is a non-halting computation.
>>>>>
>>>>> Because we know that a simulating halt decider only simulates its
>>>>> input until after it has made its halt status decision we can know
>>>>> that H can ignore its own address range in its execution traces.
>>>>>
>>>>> Because the x86 execution trace of P on input P provides no
>>>>> possible escape from infinitely nested simulation and we can
>>>>> ignore the execution trace of H then we can know that H must abort
>>>>> its simulation of P on the basis of the sixteen lines of P:
>>>>>
>>>>> _P()
>>>>> [00000b25](01) 55 push ebp
>>>>> [00000b26](02) 8bec mov ebp,esp
>>>>> [00000b28](01) 51 push ecx
>>>>> [00000b29](03) 8b4508 mov eax,[ebp+08]
>>>>> [00000b2c](01) 50 push eax
>>>>> [00000b2d](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [00000b30](01) 51 push ecx
>>>>> [00000b31](05) e81ffeffff call 00000955 // call H
>>>>>
>>>>> Begin Local Halt Decider Simulation at Machine Address:b25
>>>>> ...[00000b25][002116fe][00211702](01) 55 push ebp
>>>>> // P1 ...[00000b26][002116fe][00211702](02) 8bec mov
>>>>> ebp,esp ...[00000b28][002116fa][002016ce](01) 51 push
>>>>> ecx ...[00000b29][002116fa][002016ce](03) 8b4508 mov
>>>>> eax,[ebp+08] ...[00000b2c][002116f6][00000b25](01) 50
>>>>> push eax ...[00000b2d][002116f6][00000b25](03) 8b4d08 mov
>>>>> ecx,[ebp+08] ...[00000b30][002116f2][00000b25](01) 51
>>>>> push ecx ...[00000b31][002116ee][00000b36](05) e81ffeffff
>>>>> call 00000955 // H1 ...[00000b25][0025c126][0025c12a](01) 55
>>>>> push ebp // P2 ...[00000b26][0025c126][0025c12a](02) 8bec
>>>>> mov ebp,esp ...[00000b28][0025c122][0024c0f6](01) 51
>>>>> push ecx ...[00000b29][0025c122][0024c0f6](03) 8b4508
>>>>> mov eax,[ebp+08] ...[00000b2c][0025c11e][00000b25](01) 50
>>>>> push eax ...[00000b2d][0025c11e][00000b25](03) 8b4d08
>>>>> mov ecx,[ebp+08] ...[00000b30][0025c11a][00000b25](01) 51
>>>>> push ecx ...[00000b31][0025c116][00000b36](05) e81ffeffff
>>>>> call 00000955 // H2 Local Halt Decider: Infinite Recursion
>>>>> Detected Simulation Stopped
>>>>
>>>> But this case is trivial and uninteresting: your decider needs to
>>>> analyse branching logic predicated on arbitrary input to be
>>>> non-trivial and interesting. You've still got nothing of value to
>>>> show.
>>>>
>>>> /Flibble
>>>>
>>>>
>>>
>>> Once people comprehend that my halting criteria eliminates the
>>> pathological self-reference(Olcott 2004) of the halting problem proof
>>> counter-examples they will understand that the halting problem is not
>>> undecidable. Then teams of hundreds of software developers can handle
>>> details such as branching logic.
>>>
>
> once people comprehend that my 1000 line pspace solver
> shows P=coNP=PSPACE=#P=#Q=QSPACE
> for modestly sized N then olcotts cycle detector
> in a structure will be much less important.
> this is a theory group nitwit. get the hell out.
>
https://www.quora.com/What-are-the-greatest-proofs-in-computer-science
1. The undecidability of the Halting Problem. (Turing)
2. Undecidability of equality in CFLs. (Rice-Greibach)
3. Minimizing finite state machines in O(nlogn) (Myhill-Nerode-Hopcroft)
4. Simulating nondeterministic F(n) space in F2(n) deterministic
space. (Savitch).
5. Linear time parsing of LR grammars (Earley)
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-06 16:53 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <bf122955-9747-4a08-aa22-13a9784f5464n@googlegroups.com> |
| In reply to | #35822 |
dv is a moron. my gre scores are 2380/2400. i am willing to sell 1000 lines of bob source code to each government department that is deep into computers for one billion per copy. or they can get a free beta copy by gmail. daniel
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-06 18:56 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <cKqdnQWK2OcPcHn9nZ2dnUU7-T-dnZ2d@giganews.com> |
| In reply to | #35823 |
On 7/6/2021 6:53 PM, Daniel Pehoushek wrote: > dv is a moron. my gre scores are 2380/2400. > i am willing to sell 1000 lines of bob source code to > each government department that is deep into computers > for one billion per copy. or they can get a free > beta copy by gmail. > daniel > I don't believe you. DV is not a moron. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-06 17:46 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <adf15046-b719-4312-beff-8a91e2dc6302n@googlegroups.com> |
| In reply to | #35824 |
i suppose its relative. to me both of you are morons.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-06 19:50 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <Lv6dnZBg6N_KZ3n9nZ2dnUU7-I-dnZ2d@giganews.com> |
| In reply to | #35826 |
On 7/6/2021 7:46 PM, Daniel Pehoushek wrote: > i suppose its relative. > to me both of you are morons. > A Moron has a first grade reading level and would thus have no idea what the word "moron" means. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-06 17:56 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <31db5e29-4846-4966-9475-bad93477c2b1n@googlegroups.com> |
| In reply to | #35827 |
ok. my test score is at the seven sigma level in the distribution. five sigma society is at the five sigma level. mensans are at the three sigma level. academics are often at two sigma. moron is beneath academics. where are you?
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-06 20:18 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <V-udnWvuk4l6nXj9nZ2dnUU7-WfNnZ2d@giganews.com> |
| In reply to | #35828 |
On 7/6/2021 7:56 PM, Daniel Pehoushek wrote: > ok. my test score is at the seven sigma level in the distribution. > five sigma society is at the five sigma level. > mensans are at the three sigma level. > academics are often at two sigma. > moron is beneath academics. > where are you? > The Science of Genius By Dean Keith Simonton https://www.scientificamerican.com/magazine/special-editions/2015/01-01/ I do not believe that you have a seven sigma test score. To prove that you are lying: What percentage of the general population would have a seven sigma score (or above) according to the normal probability distribution? -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-06 18:37 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <ceccb778-ed6a-4da0-993b-45ff9c536c19n@googlegroups.com> |
| In reply to | #35829 |
i can only prove that i tell the truth. falsehood is incompatible with my mind. monotone reason is linearly decidable. #P=#Q (1997 by me): the number of satisfying assignments equals the number of valid quantifications. 1995 +vision is log base four of N pizels. CPM98: skip search (string matching) is N/M, on alphabet size two or more (cyber security). almost all ninth degree graphs are four colorable. strong color theorem: most graphs of degree d squared are d+1 colorable. P=NP for modest sizes. bob proves that. soap on the ocean implies snow on the mountains.
[toc] | [prev] | [next] | [standalone]
Page 14 of 17 — ← Prev page 1 … 12 13 [14] 15 16 17 Next page →
Back to top | Article view | comp.theory
csiph-web