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 1 of 17 [1] 2 3 … 17 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-05 11:28 -0500 |
| Subject | How do we know that H(P,P)==0 is correct? |
| Message-ID | <s7ednaA-LdLVrn79nZ2dnUU7-XvNnZ2d@giganews.com> |
The x86utm operating system was created so that the halting problem
could be examined concretely in the high level language of C.
When examining the halting problem this way every detail can be
explicitly specified. UTM tape elements are 32-bit unsigned integers.
// Simplified Linz Ĥ (Linz:1990:319)
void P(u32 x)
{
u32 Input_Halts = H(x, x);
if (Input_Halts)
HERE: goto HERE;
}
int main()
{
P((u32)P);
}
H analyzes the (currently updated) stored execution trace of its x86
emulation of P(P) after it simulates each instruction of input (P, P).
As soon as a non-halting behavior pattern is matched H aborts the
simulation of its input and decides that its input does not halt.
Every H only acts as a pure x86 emulator until some P has demonstrated
that it will never halt unless it is aborted. Because of this the
behavior of H can always be ignored in every execution trace.
The indices to H and P indicate the degree of nested simulation. It is
easily verified that the above computation never halts unless some H(n)
aborts some P(m).
If any H(n) must abort any P(m) then this H(n) does correctly decide
that this P(m) does not halt.
In the above computation (zero based addressing) H(1) aborts P(2).
Halting problem undecidability and infinitely nested simulation
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] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-07-05 13:06 -0400 |
| Message-ID | <XZGEI.2$qL.1@fx14.iad> |
| In reply to | #35756 |
On 7/5/21 12:28 PM, olcott wrote:
> The x86utm operating system was created so that the halting problem
> could be examined concretely in the high level language of C.
> When examining the halting problem this way every detail can be
> explicitly specified. UTM tape elements are 32-bit unsigned integers.
>
> // Simplified Linz Ĥ (Linz:1990:319)
> void P(u32 x)
> {
> u32 Input_Halts = H(x, x);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
> int main()
> {
> P((u32)P);
> }
>
> H analyzes the (currently updated) stored execution trace of its x86
> emulation of P(P) after it simulates each instruction of input (P, P).
> As soon as a non-halting behavior pattern is matched H aborts the
> simulation of its input and decides that its input does not halt.
>
> Every H only acts as a pure x86 emulator until some P has demonstrated
> that it will never halt unless it is aborted. Because of this the
> behavior of H can always be ignored in every execution trace.
>
> The indices to H and P indicate the degree of nested simulation. It is
> easily verified that the above computation never halts unless some H(n)
> aborts some P(m).
>
> If any H(n) must abort any P(m) then this H(n) does correctly decide
> that this P(m) does not halt.
>
> In the above computation (zero based addressing) H(1) aborts P(2).
>
> Halting problem undecidability and infinitely nested simulation
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>
So, you now do indicate somewhat via the stack address that changes on
calls.
But you still have the unsound claim that H can ignore its own behavior.
There is NO rule that allows for this, therefore the logic is unsound.
This isn't a 'property of the x86 assembly language'.
Please include a REAL proof that this is a valid operation. You won't be
able to. This is a FATAL flaw in your proof.
You also Premise(1), which you claim as an axiom is actually provable
with the proper definition of its terms, but you use different
definitions of them when you apply it to your logic, so either you have
include a false premise or made an invalid deduction in your logic.
This has been pointed out repeatedly, and you have never actually come
up with a flaw in those rebutals.
FAIL.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-05 12:17 -0500 |
| Message-ID | <bcudnQ2BPP8so379nZ2dnUU7-aGdnZ2d@giganews.com> |
| In reply to | #35759 |
On 7/5/2021 12:06 PM, Richard Damon wrote:
> On 7/5/21 12:28 PM, olcott wrote:
>> The x86utm operating system was created so that the halting problem
>> could be examined concretely in the high level language of C.
>> When examining the halting problem this way every detail can be
>> explicitly specified. UTM tape elements are 32-bit unsigned integers.
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> void P(u32 x)
>> {
>> u32 Input_Halts = H(x, x);
>> if (Input_Halts)
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> P((u32)P);
>> }
>>
>> H analyzes the (currently updated) stored execution trace of its x86
>> emulation of P(P) after it simulates each instruction of input (P, P).
>> As soon as a non-halting behavior pattern is matched H aborts the
>> simulation of its input and decides that its input does not halt.
>>
>> Every H only acts as a pure x86 emulator until some P has demonstrated
>> that it will never halt unless it is aborted. Because of this the
>> behavior of H can always be ignored in every execution trace.
>>
>> The indices to H and P indicate the degree of nested simulation. It is
>> easily verified that the above computation never halts unless some H(n)
>> aborts some P(m).
>>
>> If any H(n) must abort any P(m) then this H(n) does correctly decide
>> that this P(m) does not halt.
>>
>> In the above computation (zero based addressing) H(1) aborts P(2).
>>
>> Halting problem undecidability and infinitely nested simulation
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>
>>
>
> So, you now do indicate somewhat via the stack address that changes on
> calls.
>
> But you still have the unsound claim that H can ignore its own behavior.
That a simulating halt decider only aborts its input after its input has
demonstrated non-halting behavior and acts as a pure simulator until
then seems to be above your capacity to comprehend.
--
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-05 13:54 -0400 |
| Message-ID | <tHHEI.27500$P64.19663@fx47.iad> |
| In reply to | #35763 |
On 7/5/21 1:17 PM, olcott wrote:
> On 7/5/2021 12:06 PM, Richard Damon wrote:
>> On 7/5/21 12:28 PM, olcott wrote:
>>> The x86utm operating system was created so that the halting problem
>>> could be examined concretely in the high level language of C.
>>> When examining the halting problem this way every detail can be
>>> explicitly specified. UTM tape elements are 32-bit unsigned integers.
>>>
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> void P(u32 x)
>>> {
>>> u32 Input_Halts = H(x, x);
>>> if (Input_Halts)
>>> HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> P((u32)P);
>>> }
>>>
>>> H analyzes the (currently updated) stored execution trace of its x86
>>> emulation of P(P) after it simulates each instruction of input (P, P).
>>> As soon as a non-halting behavior pattern is matched H aborts the
>>> simulation of its input and decides that its input does not halt.
>>>
>>> Every H only acts as a pure x86 emulator until some P has demonstrated
>>> that it will never halt unless it is aborted. Because of this the
>>> behavior of H can always be ignored in every execution trace.
>>>
>>> The indices to H and P indicate the degree of nested simulation. It is
>>> easily verified that the above computation never halts unless some H(n)
>>> aborts some P(m).
>>>
>>> If any H(n) must abort any P(m) then this H(n) does correctly decide
>>> that this P(m) does not halt.
>>>
>>> In the above computation (zero based addressing) H(1) aborts P(2).
>>>
>>> Halting problem undecidability and infinitely nested simulation
>>>
>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>
>>>
>>>
>>
>> So, you now do indicate somewhat via the stack address that changes on
>> calls.
>>
>> But you still have the unsound claim that H can ignore its own behavior.
>
> That a simulating halt decider only aborts its input after its input has
> demonstrated non-halting behavior and acts as a pure simulator until
> then seems to be above your capacity to comprehend.
>
That you need to actually PROVE your assertions seems to be beyond yours.
H does NOT see actual PROOF of non-Halting behavior, because H ignores
that fact that the H within P can and will abort the simulation and thus
make P a Halting Computation. By assuming that the embedded H will not
abort its simulation, the simulating H makes an unsound conclusion, and
is thus wrong.
The simulation H doesn't get enough information to make its decision,
but part of the problem is that is CAN'T simulate long enough to get the
information to make its decision, as when it delays its decision, so
does the the copy it is simulating.
In every case, if H does at some point stop its simulation and return an
answer, the structure of the P that is built on that H will make sure
that answer is wrong. This doesn't prove that P is non-Halting, it just
proves that the correctly answering H doesn't exist.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-05 14:30 -0500 |
| Message-ID | <17udnTB87NN_wH79nZ2dnUU7-UXNnZ2d@giganews.com> |
| In reply to | #35767 |
On 7/5/2021 12:54 PM, Richard Damon wrote:
> On 7/5/21 1:17 PM, olcott wrote:
>> On 7/5/2021 12:06 PM, Richard Damon wrote:
>>> On 7/5/21 12:28 PM, olcott wrote:
>>>> The x86utm operating system was created so that the halting problem
>>>> could be examined concretely in the high level language of C.
>>>> When examining the halting problem this way every detail can be
>>>> explicitly specified. UTM tape elements are 32-bit unsigned integers.
>>>>
>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>> void P(u32 x)
>>>> {
>>>> u32 Input_Halts = H(x, x);
>>>> if (Input_Halts)
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> P((u32)P);
>>>> }
>>>>
>>>> H analyzes the (currently updated) stored execution trace of its x86
>>>> emulation of P(P) after it simulates each instruction of input (P, P).
>>>> As soon as a non-halting behavior pattern is matched H aborts the
>>>> simulation of its input and decides that its input does not halt.
>>>>
>>>> Every H only acts as a pure x86 emulator until some P has demonstrated
>>>> that it will never halt unless it is aborted. Because of this the
>>>> behavior of H can always be ignored in every execution trace.
>>>>
>>>> The indices to H and P indicate the degree of nested simulation. It is
>>>> easily verified that the above computation never halts unless some H(n)
>>>> aborts some P(m).
>>>>
>>>> If any H(n) must abort any P(m) then this H(n) does correctly decide
>>>> that this P(m) does not halt.
>>>>
>>>> In the above computation (zero based addressing) H(1) aborts P(2).
>>>>
>>>> Halting problem undecidability and infinitely nested simulation
>>>>
>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>
>>>>
>>>>
>>>
>>> So, you now do indicate somewhat via the stack address that changes on
>>> calls.
>>>
>>> But you still have the unsound claim that H can ignore its own behavior.
>>
>> That a simulating halt decider only aborts its input after its input has
>> demonstrated non-halting behavior and acts as a pure simulator until
>> then seems to be above your capacity to comprehend.
>>
>
> That you need to actually PROVE your assertions seems to be beyond yours.
>
> H does NOT see actual PROOF of non-Halting behavior, because H ignores
> that fact that the H within P can and will abort the simulation and thus
> make P a Halting Computation.
This really really seems to be beyond your capacity to understand:
H never ever gets to the point in its own execution where it aborts the
simulation of its input until AFTER its input has already proven that it
will never halt unless aborted.
I have told that twenty times now and you still don't get it.
I have told that twenty times now and you still don't get it.
I have told that twenty times now and you still don't get it.
I have told that twenty times now and you still don't get it.
I have told that twenty times now and you still don't get it.
When H simulates inputs that halt H ONLY acts as a pure simulator until
these inputs halt on their own.
--
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-05 15:54 -0400 |
| Message-ID | <asJEI.2$7H7.1@fx42.iad> |
| In reply to | #35769 |
On 7/5/21 3:30 PM, olcott wrote:
> On 7/5/2021 12:54 PM, Richard Damon wrote:
>> On 7/5/21 1:17 PM, olcott wrote:
>>> On 7/5/2021 12:06 PM, Richard Damon wrote:
>>>> On 7/5/21 12:28 PM, olcott wrote:
>>>>> The x86utm operating system was created so that the halting problem
>>>>> could be examined concretely in the high level language of C.
>>>>> When examining the halting problem this way every detail can be
>>>>> explicitly specified. UTM tape elements are 32-bit unsigned integers.
>>>>>
>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>> void P(u32 x)
>>>>> {
>>>>> u32 Input_Halts = H(x, x);
>>>>> if (Input_Halts)
>>>>> HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> P((u32)P);
>>>>> }
>>>>>
>>>>> H analyzes the (currently updated) stored execution trace of its x86
>>>>> emulation of P(P) after it simulates each instruction of input (P, P).
>>>>> As soon as a non-halting behavior pattern is matched H aborts the
>>>>> simulation of its input and decides that its input does not halt.
>>>>>
>>>>> Every H only acts as a pure x86 emulator until some P has demonstrated
>>>>> that it will never halt unless it is aborted. Because of this the
>>>>> behavior of H can always be ignored in every execution trace.
>>>>>
>>>>> The indices to H and P indicate the degree of nested simulation. It is
>>>>> easily verified that the above computation never halts unless some
>>>>> H(n)
>>>>> aborts some P(m).
>>>>>
>>>>> If any H(n) must abort any P(m) then this H(n) does correctly decide
>>>>> that this P(m) does not halt.
>>>>>
>>>>> In the above computation (zero based addressing) H(1) aborts P(2).
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>
>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>
>>>>>
>>>>>
>>>>>
>>>>
>>>> So, you now do indicate somewhat via the stack address that changes on
>>>> calls.
>>>>
>>>> But you still have the unsound claim that H can ignore its own
>>>> behavior.
>>>
>>> That a simulating halt decider only aborts its input after its input has
>>> demonstrated non-halting behavior and acts as a pure simulator until
>>> then seems to be above your capacity to comprehend.
>>>
>>
>> That you need to actually PROVE your assertions seems to be beyond yours.
>>
>> H does NOT see actual PROOF of non-Halting behavior, because H ignores
>> that fact that the H within P can and will abort the simulation and thus
>> make P a Halting Computation.
>
> This really really seems to be beyond your capacity to understand:
>
> H never ever gets to the point in its own execution where it aborts the
> simulation of its input until AFTER its input has already proven that it
> will never halt unless aborted.
>
> I have told that twenty times now and you still don't get it.
> I have told that twenty times now and you still don't get it.
> I have told that twenty times now and you still don't get it.
> I have told that twenty times now and you still don't get it.
> I have told that twenty times now and you still don't get it.
>
> When H simulates inputs that halt H ONLY acts as a pure simulator until
> these inputs halt on their own.
>
And you don't seem to understand that it doesn't matter WHEN it get to
the point of aborting the simulation, if it WILL get to that point, you
need to account for it.
Do you disagree that P(P) when run as an actual program will Halt? You
have admitted that it does in the past.
If it doesn't halt, which step here is wrong?
1) H determines that H(P,P) is non-Halting.
2) H returns that non-Halting decision to its caller.
3) That P when it gets that answer does Halt.
Note, if in 2, H doesn't return the answer, it fails to be a decider,
just 'making' the decison isn't enough, it has to return the answer.
If in 2, H returns the answer to main but not to P then H has failed to
be a computation and thus isn't a valid Halt Decider either.
If in 3, then you built your P wrong.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-07-05 22:34 +0100 |
| Message-ID | <87zgv0a1hs.fsf@bsb.me.uk> |
| In reply to | #35756 |
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.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-05 16:40 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <K8qdnYMPD9vA4X79nZ2dnUU7-XHNnZ2d@giganews.com> |
| In reply to | #35772 |
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.
--
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-05 17:48 -0400 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <T6LEI.4$r21.3@fx38.iad> |
| In reply to | #35773 |
On 7/5/21 5:40 PM, olcott wrote:
> 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.
>
>
Except that it doesn't. You NEVER have to (or are even able to) abort
the instance of P that is called from main. THAT is the actual computation.
Yes, within the processing of P, H will be given a representation of P
and P and that H will decide to abort its simulation of that
representation of P, but that is NOT the instance that matters.
The Turing Machine P represented by that call to P from main, WILL reach
its final Halting State in a finite number of step, and thus be a
Halting Computation.
You seem to not be able to keep different instances of things with the
same (or even simlar) names seperate in your mind.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-05 17:41 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <jqWdnYYQk846F379nZ2dnUU7-T9QAAAA@giganews.com> |
| In reply to | #35774 |
On 7/5/2021 4:48 PM, Richard Damon wrote:
> On 7/5/21 5:40 PM, olcott wrote:
>> 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.
>>
>>
>
> Except that it doesn't. You NEVER have to (or are even able to) abort
> the instance of P that is called from main. THAT is the actual computation.
>
the above computation must be aborted at some point or it never halts
the above computation must be aborted at some point or it never halts
the above computation must be aborted at some point or it never halts
the above computation must be aborted at some point or it never halts
> Yes, within the processing of P, H will be given a representation of P
> and P and that H will decide to abort its simulation of that
> representation of P, but that is NOT the instance that matters.
>
> The Turing Machine P represented by that call to P from main, WILL reach
> its final Halting State in a finite number of step, and thus be a
> Halting Computation.
>
> You seem to not be able to keep different instances of things with the
> same (or even simlar) names seperate in your mind.
>
It does not freaking matter what point the computation is aborted
It does not freaking matter what point the computation is aborted
It does not freaking matter what point the computation is aborted
It does not freaking matter what point the computation is aborted
--
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-05 19:14 -0400 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <5nMEI.160$tL2.9@fx43.iad> |
| In reply to | #35776 |
On 7/5/21 6:41 PM, olcott wrote:
> On 7/5/2021 4:48 PM, Richard Damon wrote:
>> On 7/5/21 5:40 PM, olcott wrote:
>>> 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.
>>>
>>>
>>
>> Except that it doesn't. You NEVER have to (or are even able to) abort
>> the instance of P that is called from main. THAT is the actual
>> computation.
>>
>
> the above computation must be aborted at some point or it never halts
> the above computation must be aborted at some point or it never halts
> the above computation must be aborted at some point or it never halts
> the above computation must be aborted at some point or it never halts
>
WRONG
WRONG
WRONG
>
>> Yes, within the processing of P, H will be given a representation of P
>> and P and that H will decide to abort its simulation of that
>> representation of P, but that is NOT the instance that matters.
>>
>> The Turing Machine P represented by that call to P from main, WILL reach
>> its final Halting State in a finite number of step, and thus be a
>> Halting Computation.
>>
>> You seem to not be able to keep different instances of things with the
>> same (or even simlar) names seperate in your mind.
>>
>
> It does not freaking matter what point the computation is aborted
> It does not freaking matter what point the computation is aborted
> It does not freaking matter what point the computation is aborted
> It does not freaking matter what point the computation is aborted
>
But it does matter WHICH computation is aborted.
In the above computation
Main call P0.
P0 calls H0 as part of its execution.
H0 simulates a NEW computaton, P1.
We now have two computations in process, P0/H0 doing a simulation, and a
P1/H1 that is being simulated.
These are distinct.
This P1 calls H1 to decide on P2.
At this point H0 incorrectly decides that P1 is non-halting and aborts P1/H1
H0 then returns its answer to P0 and P0 Halts
P0 was NEVER aborted. In fact, P0/H0 DID the aborting of P1/H1.
Thus, P is a Halting computation. DEFINITION.
Note P0/H0 is a distinct computation to P1/H1. In fact, P1/H1 isn't
actually being run as a actual machine, but only in the virtual machine
created by H0.
This is why we need to keep track of them separately.
Yes, there are rules that allow us to IN SPECIFIC CASES, treat the
virtual computation being simulated as actually being part of the
simulating machine, but these don't apply in this case.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-07-06 00:15 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (Ben's double-talk does not work) |
| Message-ID | <87o8bg9wt8.fsf@bsb.me.uk> |
| In reply to | #35773 |
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.)
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-05 19:04 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) |
| Message-ID | <dNKdnYB3yu2AA379nZ2dnUU7-QPNnZ2d@giganews.com> |
| In reply to | #35779 |
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.)
>
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run
forever. https://en.wikipedia.org/wiki/Halting_problem
(1) At least one way to circumvent the pathological self-reference
(olcott 2004) of the halting problem counter-example templates is with a
simulating halt decider.
void Infinite_Loop()
{
HERE: goto HERE;
}
int main()
{
u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
Output("Input_Would_Halt2 = ", Input_Would_Halt2);
}
(2) Because every input to a simulating halt decider either halts on its
own or must have its simulation terminated: all simulations that must be
terminated are correctly construed as non-halting computations.
(3) This criterion measure defines the exact same halting / not halting
sets as the halting problem. Every element P(I) that was a halting
computation remains a halting computation. Every element P(I) that was a
non-halting computation remains a non-halting computation.
The only thing that has changed is that undecidable inputs can no longer
be defined. Every TM / input pair falls into exactly one of two sets:
(a) Halting
(b) Non-halting
--
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-05 20:45 -0400 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) |
| Message-ID | <xINEI.710$Q75.666@fx24.iad> |
| In reply to | #35780 |
On 7/5/21 8:04 PM, olcott wrote:
> In computability theory, the halting problem is the problem of
> determining, from a description of an arbitrary computer program and an
> input, whether the program will finish running, or continue to run
> forever. https://en.wikipedia.org/wiki/Halting_problem
>
> (1) At least one way to circumvent the pathological self-reference
> (olcott 2004) of the halting problem counter-example templates is with a
> simulating halt decider.
>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> int main()
> {
> u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
> Output("Input_Would_Halt2 = ", Input_Would_Halt2);
> }
>
> (2) Because every input to a simulating halt decider either halts on its
> own or must have its simulation terminated: all simulations that must be
> terminated are correctly construed as non-halting computations.
>
> (3) This criterion measure defines the exact same halting / not halting
> sets as the halting problem. Every element P(I) that was a halting
> computation remains a halting computation. Every element P(I) that was a
> non-halting computation remains a non-halting computation.
>
> The only thing that has changed is that undecidable inputs can no longer
> be defined. Every TM / input pair falls into exactly one of two sets:
> (a) Halting
> (b) Non-halting
>
Problem is that this doesn't change the challenge of the ^ machine.
The definition of Halting DOES NOT CHANGE. It is still does P(I), when
run, come to its halt in a fininite number of steps or not. You do NOT
get to change the criterion.
Your statement defines the condition your algorithm might want to use to
make its decision, but the ultimate test is STILL the original
definition, applied to the running of P(I), and not looking at what
happened during the running of H(P,I).
Your H STILL must be a real computation, must return its answer to
whoever calls it (and the same answer to all callers for the same input).
H^ (which call P) will still call H with two copies of itself, and H
must return an answer to it on its decision, and it will still act contrary.
The fact that the general form of decider, working on a basis of
simulation, is going to need to be able to abort some simulations to be
able to give an answer, doesn't give it license to change the 'rules' of
the game.
In particular, the form that is troublesome for this form, the machines
that are built on copies of itself, don't give it any special licence
for diffferent rules, even though this can lead to some problems that
impossible to answer correctly, the ability to make such machine just
make it easy to show that there are some machines that it just won't be
able to handle.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-05 20:01 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) |
| Message-ID | <-PadnWUgW6LwNn79nZ2dnUU7-S3NnZ2d@giganews.com> |
| In reply to | #35782 |
On 7/5/2021 7:45 PM, Richard Damon wrote:
> On 7/5/21 8:04 PM, olcott wrote:
>
>> In computability theory, the halting problem is the problem of
>> determining, from a description of an arbitrary computer program and an
>> input, whether the program will finish running, or continue to run
>> forever. https://en.wikipedia.org/wiki/Halting_problem
>>
>> (1) At least one way to circumvent the pathological self-reference
>> (olcott 2004) of the halting problem counter-example templates is with a
>> simulating halt decider.
>>
>> void Infinite_Loop()
>> {
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>> Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>> }
>>
>> (2) Because every input to a simulating halt decider either halts on its
>> own or must have its simulation terminated: all simulations that must be
>> terminated are correctly construed as non-halting computations.
>>
>> (3) This criterion measure defines the exact same halting / not halting
>> sets as the halting problem. Every element P(I) that was a halting
>> computation remains a halting computation. Every element P(I) that was a
>> non-halting computation remains a non-halting computation.
>>
>> The only thing that has changed is that undecidable inputs can no longer
>> be defined. Every TM / input pair falls into exactly one of two sets:
>> (a) Halting
>> (b) Non-halting
>>
>
> Problem is that this doesn't change the challenge of the ^ machine.
>
> The definition of Halting DOES NOT CHANGE.
Because every element of the set of computations that never halt unless
their simulation is aborted maps to every element of the set of
non-halting computations we know that it is an equivalent criterion
measure that defines the same set.
--
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-05 21:22 -0400 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) |
| Message-ID | <6fOEI.711$Q75.95@fx24.iad> |
| In reply to | #35784 |
On 7/5/21 9:01 PM, olcott wrote:
> On 7/5/2021 7:45 PM, Richard Damon wrote:
>> On 7/5/21 8:04 PM, olcott wrote:
>>
>>> In computability theory, the halting problem is the problem of
>>> determining, from a description of an arbitrary computer program and an
>>> input, whether the program will finish running, or continue to run
>>> forever. https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> (1) At least one way to circumvent the pathological self-reference
>>> (olcott 2004) of the halting problem counter-example templates is with a
>>> simulating halt decider.
>>>
>>> void Infinite_Loop()
>>> {
>>> HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>>> Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>>> }
>>>
>>> (2) Because every input to a simulating halt decider either halts on its
>>> own or must have its simulation terminated: all simulations that must be
>>> terminated are correctly construed as non-halting computations.
>>>
>>> (3) This criterion measure defines the exact same halting / not halting
>>> sets as the halting problem. Every element P(I) that was a halting
>>> computation remains a halting computation. Every element P(I) that was a
>>> non-halting computation remains a non-halting computation.
>>>
>>> The only thing that has changed is that undecidable inputs can no longer
>>> be defined. Every TM / input pair falls into exactly one of two sets:
>>> (a) Halting
>>> (b) Non-halting
>>>
>>
>> Problem is that this doesn't change the challenge of the ^ machine.
>>
>> The definition of Halting DOES NOT CHANGE.
>
> Because every element of the set of computations that never halt unless
> their simulation is aborted maps to every element of the set of
> non-halting computations we know that it is an equivalent criterion
> measure that defines the same set.
>
If it WAS an equivalnet set, then H^(H^) wouldn't be on different sides
for the two divides.
It IS a computation that Halts, and thus NOT in the set of non-Halting
computations. By your logic, it needs to be classified in the set of
computations that never halt unless there simulation is aborted.
Thus by your logic, they aren't equivalent sets.
Ultimately the problem is you mis-define that later set, with the proper
definition the equivalence does hold. The definition that does this is
that it means that if the simulation would be unending unless the
instance of the simulator that doing that simulation actually needs to
abort the simulation, but replacing it with a pure non-aborting
simulator would yield an infinite simulation. THAT definition works, not
your crasy one the includes other copies of the algorithm aborting other
copies of the machine.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-05 21:37 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) |
| Message-ID | <9LKdnRvoPLyUX379nZ2dnUU7-f_NnZ2d@giganews.com> |
| In reply to | #35785 |
On 7/5/2021 8:22 PM, Richard Damon wrote:
> On 7/5/21 9:01 PM, olcott wrote:
>> On 7/5/2021 7:45 PM, Richard Damon wrote:
>>> On 7/5/21 8:04 PM, olcott wrote:
>>>
>>>> In computability theory, the halting problem is the problem of
>>>> determining, from a description of an arbitrary computer program and an
>>>> input, whether the program will finish running, or continue to run
>>>> forever. https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> (1) At least one way to circumvent the pathological self-reference
>>>> (olcott 2004) of the halting problem counter-example templates is with a
>>>> simulating halt decider.
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>>>> Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>>>> }
>>>>
>>>> (2) Because every input to a simulating halt decider either halts on its
>>>> own or must have its simulation terminated: all simulations that must be
>>>> terminated are correctly construed as non-halting computations.
>>>>
>>>> (3) This criterion measure defines the exact same halting / not halting
>>>> sets as the halting problem. Every element P(I) that was a halting
>>>> computation remains a halting computation. Every element P(I) that was a
>>>> non-halting computation remains a non-halting computation.
>>>>
>>>> The only thing that has changed is that undecidable inputs can no longer
>>>> be defined. Every TM / input pair falls into exactly one of two sets:
>>>> (a) Halting
>>>> (b) Non-halting
>>>>
>>>
>>> Problem is that this doesn't change the challenge of the ^ machine.
>>>
>>> The definition of Halting DOES NOT CHANGE.
>>
>> Because every element of the set of computations that never halt unless
>> their simulation is aborted maps to every element of the set of
>> non-halting computations we know that it is an equivalent criterion
>> measure that defines the same set.
>>
>
> If it WAS an equivalnet set, then H^(H^) wouldn't be on different sides
> for the two divides.
>
The simulating halt decider has two crucial phases:
(1) It is only a simulator until its input proves that it will never
halt unless aborted.
At this point we have perfect certainty that the simulating halt decider
is correct.
(2) After its input proves that it will never halt unless its simulation
an aborted its input is aborted.
> It IS a computation that Halts, and thus NOT in the set of non-Halting
> computations. By your logic, it needs to be classified in the set of
> computations that never halt unless there simulation is aborted.
>
> Thus by your logic, they aren't equivalent sets.
>
> Ultimately the problem is you mis-define that later set, with the proper
> definition the equivalence does hold. The definition that does this is
> that it means that if the simulation would be unending unless the
> instance of the simulator that doing that simulation actually needs to
> abort the simulation, but replacing it with a pure non-aborting
> simulator would yield an infinite simulation. THAT definition works, not
> your crasy one the includes other copies of the algorithm aborting other
> copies of the machine.
>
--
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 06:38 -0400 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) |
| Message-ID | <XoWEI.2291$Vv6.2142@fx45.iad> |
| In reply to | #35789 |
On 7/5/21 10:37 PM, olcott wrote:
> On 7/5/2021 8:22 PM, Richard Damon wrote:
>> On 7/5/21 9:01 PM, olcott wrote:
>>> On 7/5/2021 7:45 PM, Richard Damon wrote:
>>>> On 7/5/21 8:04 PM, olcott wrote:
>>>>
>>>>> In computability theory, the halting problem is the problem of
>>>>> determining, from a description of an arbitrary computer program
>>>>> and an
>>>>> input, whether the program will finish running, or continue to run
>>>>> forever. https://en.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> (1) At least one way to circumvent the pathological self-reference
>>>>> (olcott 2004) of the halting problem counter-example templates is
>>>>> with a
>>>>> simulating halt decider.
>>>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>> HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>>>>> Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>>>>> }
>>>>>
>>>>> (2) Because every input to a simulating halt decider either halts
>>>>> on its
>>>>> own or must have its simulation terminated: all simulations that
>>>>> must be
>>>>> terminated are correctly construed as non-halting computations.
>>>>>
>>>>> (3) This criterion measure defines the exact same halting / not
>>>>> halting
>>>>> sets as the halting problem. Every element P(I) that was a halting
>>>>> computation remains a halting computation. Every element P(I) that
>>>>> was a
>>>>> non-halting computation remains a non-halting computation.
>>>>>
>>>>> The only thing that has changed is that undecidable inputs can no
>>>>> longer
>>>>> be defined. Every TM / input pair falls into exactly one of two sets:
>>>>> (a) Halting
>>>>> (b) Non-halting
>>>>>
>>>>
>>>> Problem is that this doesn't change the challenge of the ^ machine.
>>>>
>>>> The definition of Halting DOES NOT CHANGE.
>>>
>>> Because every element of the set of computations that never halt unless
>>> their simulation is aborted maps to every element of the set of
>>> non-halting computations we know that it is an equivalent criterion
>>> measure that defines the same set.
>>>
>>
>> If it WAS an equivalnet set, then H^(H^) wouldn't be on different sides
>> for the two divides.
>>
>
> The simulating halt decider has two crucial phases:
> (1) It is only a simulator until its input proves that it will never
> halt unless aborted.
>
> At this point we have perfect certainty that the simulating halt decider
> is correct.
>
No, since the Halt Decider WILL enter the second phase, it needs to
analyze copies of itself knowing that it will do that.
> (2) After its input proves that it will never halt unless its simulation
> an aborted its input is aborted.
But it never did PROVE that, since it ignores behavor that is part of H.
This is CLEARLY seen by actually seeing what P(P) actually does when
run, which is to Halt at its end, as even YOU have shown.
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-06 04:14 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) |
| Message-ID | <8556f19c-6b53-464b-9234-94280a87cd4bn@googlegroups.com> |
| In reply to | #35794 |
this is a theory group. get the hell out.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-07-06 03:33 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (correct halt deciding criterion measure) |
| Message-ID | <87fsws9nni.fsf@bsb.me.uk> |
| In reply to | #35780 |
olcott <NoOne@NoWhere.com> writes:
> 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.
> In computability theory, the halting problem is the problem of
> determining, from a description of an arbitrary computer program and
> an input, whether the program will finish running, or continue to run
> forever. https://en.wikipedia.org/wiki/Halting_problem
Yes, that's why H(P,P) == 0 is wrong (as far as halting is concerned)
when P(P) halts.
> (1) At least one way to circumvent the pathological self-reference
> (olcott 2004) of the halting problem counter-example templates is with
> a simulating halt decider.
>
> (2) Because every input to a simulating halt decider either halts on
> its own or must have its simulation terminated: all simulations that
> must be terminated are correctly construed as non-halting
> computations.
The only computations that should be construed as non-halting are the
ones that don't halt. Why does this still need to be said? Have you
simply lost the plot?
> (3) This criterion measure defines the exact same halting / not
> halting sets as the halting problem.
Not according to you. P(P) halts but it's non-POOH because it halts in
the way you decided is "special".
> Every element P(I) that was a
> halting computation remains a halting computation. Every element P(I)
> that was a non-halting computation remains a non-halting computation.
Not according to you. If they were the same, you'd agree that every
instance of the halting problem has a correct yes/no answer and that yes
is only correct for those strings that represent halting computations.
But despite endlessly quoting Wikipedia and Linz you reject this
definition in favour of POOH.
> The only thing that has changed is that undecidable inputs can no
> longer be defined. Every TM / input pair falls into exactly one of two
> sets:
> (a) Halting
> (b) Non-halting
Actually you can't do this even for the POOH problem, but since you
don't engage with difficult topics, there's no way I can explain to you
why.
--
Ben.
[toc] | [prev] | [next] | [standalone]
Page 1 of 17 [1] 2 3 … 17 Next page →
Back to top | Article view | comp.theory
csiph-web