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 5 of 17 — ← Prev page 1 … 3 4 [5] 6 7 … 17 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-09 12:47 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <4K2dnR6DL908FnX9nZ2dnUU7-bHNnZ2d@giganews.com> |
| In reply to | #35983 |
On 7/9/2021 12:06 PM, Mr Flibble wrote: > On Fri, 9 Jul 2021 08:59:51 -0500 > olcott <NoOne@NoWhere.com> wrote: >> [Halt Deciding Axiom] When the pure simulation of the machine >> description ⟨P⟩ of a machine P on its input I never halts we know >> that P(I) never halts. >> >> No we cannot. In order to remove the pathological feedback loop such >> that P does the opposite of whatever H decides H simply acts as a >> pure simulator of P thus having no effect what-so-ever on the >> behavior of P until after its halt status decision has been made. > > Except your decider can only handle trivial uninteresting cases: if you > wish to make progress on this then prove your decider works with a > non-trivial case which includes branching logic predicated on arbitrary > program input that is unknown a priori to the simulation starting; but > before you even do that prove your decider works with a non-trivial > case with branching logic predicated on arbitrary program input that > *is* known a priori. > You continue to prove to everyone that actually knows these things that you are an ignoramus on this subject. That H correctly decides that all of the standard counter-examples templates never halt eliminates the entire basis of all of the conventional halting problem undecidability proofs. > I also note that you repeatedly refuse to address my point regarding how > x86 mov instructions can read/write from/to memory mapped I/O > rather than RAM so the result of the mov instruction cannot be known a > priori. The halting program concerns computing devices and a computing > device which cannot do I/O is next to useless, much like your decider > (until you actually prove otherwise which I have a feeling is never > going to happen as you appear to be stuck in a loop). > > /Flibble > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-09 20:16 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <20210709201639.00001fe7@reddwarf.jmc> |
| In reply to | #35984 |
On Fri, 9 Jul 2021 12:47:12 -0500 olcott <NoOne@NoWhere.com> wrote: > On 7/9/2021 12:06 PM, Mr Flibble wrote: > > On Fri, 9 Jul 2021 08:59:51 -0500 > > olcott <NoOne@NoWhere.com> wrote: > >> [Halt Deciding Axiom] When the pure simulation of the machine > >> description ⟨P⟩ of a machine P on its input I never halts we know > >> that P(I) never halts. > >> > >> No we cannot. In order to remove the pathological feedback loop > >> such that P does the opposite of whatever H decides H simply acts > >> as a pure simulator of P thus having no effect what-so-ever on the > >> behavior of P until after its halt status decision has been made. > > > > Except your decider can only handle trivial uninteresting cases: if > > you wish to make progress on this then prove your decider works > > with a non-trivial case which includes branching logic predicated > > on arbitrary program input that is unknown a priori to the > > simulation starting; but before you even do that prove your decider > > works with a non-trivial case with branching logic predicated on > > arbitrary program input that *is* known a priori. > > > > You continue to prove to everyone that actually knows these things > that you are an ignoramus on this subject. > > That H correctly decides that all of the standard counter-examples > templates never halt eliminates the entire basis of all of the > conventional halting problem undecidability proofs. > > > I also note that you repeatedly refuse to address my point > > regarding how x86 mov instructions can read/write from/to memory > > mapped I/O rather than RAM so the result of the mov instruction > > cannot be known a priori. The halting program concerns computing > > devices and a computing device which cannot do I/O is next to > > useless, much like your decider (until you actually prove otherwise > > which I have a feeling is never going to happen as you appear to be > > stuck in a loop). > > > > /Flibble > > > > I continue to note that you repeatedly refuse to address my point regarding how x86 mov instructions can read/write from/to memory mapped I/O rather than RAM so the result of the mov instruction cannot be known a priori. The halting program concerns computing devices and a computing device which cannot do I/O is next to useless, much like your decider (until you actually prove otherwise which I have a feeling is never going to happen as you appear to be stuck in a loop). /Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-09 14:24 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <PcudnVi3q7bvP3X9nZ2dnUU7-IOdnZ2d@giganews.com> |
| In reply to | #35987 |
On 7/9/2021 2:16 PM, Mr Flibble wrote: > On Fri, 9 Jul 2021 12:47:12 -0500 > olcott <NoOne@NoWhere.com> wrote: > >> On 7/9/2021 12:06 PM, Mr Flibble wrote: >>> On Fri, 9 Jul 2021 08:59:51 -0500 >>> olcott <NoOne@NoWhere.com> wrote: >>>> [Halt Deciding Axiom] When the pure simulation of the machine >>>> description ⟨P⟩ of a machine P on its input I never halts we know >>>> that P(I) never halts. >>>> >>>> No we cannot. In order to remove the pathological feedback loop >>>> such that P does the opposite of whatever H decides H simply acts >>>> as a pure simulator of P thus having no effect what-so-ever on the >>>> behavior of P until after its halt status decision has been made. >>> >>> Except your decider can only handle trivial uninteresting cases: if >>> you wish to make progress on this then prove your decider works >>> with a non-trivial case which includes branching logic predicated >>> on arbitrary program input that is unknown a priori to the >>> simulation starting; but before you even do that prove your decider >>> works with a non-trivial case with branching logic predicated on >>> arbitrary program input that *is* known a priori. >>> >> >> You continue to prove to everyone that actually knows these things >> that you are an ignoramus on this subject. >> >> That H correctly decides that all of the standard counter-examples >> templates never halt eliminates the entire basis of all of the >> conventional halting problem undecidability proofs. >> >>> I also note that you repeatedly refuse to address my point >>> regarding how x86 mov instructions can read/write from/to memory >>> mapped I/O rather than RAM so the result of the mov instruction >>> cannot be known a priori. The halting program concerns computing >>> devices and a computing device which cannot do I/O is next to >>> useless, much like your decider (until you actually prove otherwise >>> which I have a feeling is never going to happen as you appear to be >>> stuck in a loop). >>> >>> /Flibble >>> >> >> > > I continue to note that you repeatedly refuse to address my point > regarding how x86 mov instructions can read/write from/to memory mapped > I/O rather than RAM so the result of the mov instruction cannot be > known a priori. The halting program concerns computing devices and a > computing device which cannot do I/O is next to useless, much like your > decider (until you actually prove otherwise which I have a feeling is > never going to happen as you appear to be stuck in a loop). > > /Flibble > You are the only one that believes that your points have any relevance. That you believe that data movement instructions have anything to do with control flow proves that your points have no relevance. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-09 12:33 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <0a938e79-0755-4ba3-ae63-8626eacc343cn@googlegroups.com> |
| In reply to | #35988 |
equal in identity unequal in mass these trees of life on all tree land planets sea shells by the sea shore beer beer beer racial memory stars to holes in formations racial memories of trees with or without monkeys
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-09 22:08 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <20210709220803.000050f1@reddwarf.jmc> |
| In reply to | #35988 |
On Fri, 9 Jul 2021 14:24:33 -0500 olcott <NoOne@NoWhere.com> wrote: > On 7/9/2021 2:16 PM, Mr Flibble wrote: > > On Fri, 9 Jul 2021 12:47:12 -0500 > > olcott <NoOne@NoWhere.com> wrote: > > > >> On 7/9/2021 12:06 PM, Mr Flibble wrote: > >>> On Fri, 9 Jul 2021 08:59:51 -0500 > >>> olcott <NoOne@NoWhere.com> wrote: > >>>> [Halt Deciding Axiom] When the pure simulation of the machine > >>>> description ⟨P⟩ of a machine P on its input I never halts we know > >>>> that P(I) never halts. > >>>> > >>>> No we cannot. In order to remove the pathological feedback loop > >>>> such that P does the opposite of whatever H decides H simply acts > >>>> as a pure simulator of P thus having no effect what-so-ever on > >>>> the behavior of P until after its halt status decision has been > >>>> made. > >>> > >>> Except your decider can only handle trivial uninteresting cases: > >>> if you wish to make progress on this then prove your decider works > >>> with a non-trivial case which includes branching logic predicated > >>> on arbitrary program input that is unknown a priori to the > >>> simulation starting; but before you even do that prove your > >>> decider works with a non-trivial case with branching logic > >>> predicated on arbitrary program input that *is* known a priori. > >>> > >> > >> You continue to prove to everyone that actually knows these things > >> that you are an ignoramus on this subject. > >> > >> That H correctly decides that all of the standard counter-examples > >> templates never halt eliminates the entire basis of all of the > >> conventional halting problem undecidability proofs. > >> > >>> I also note that you repeatedly refuse to address my point > >>> regarding how x86 mov instructions can read/write from/to memory > >>> mapped I/O rather than RAM so the result of the mov instruction > >>> cannot be known a priori. The halting program concerns computing > >>> devices and a computing device which cannot do I/O is next to > >>> useless, much like your decider (until you actually prove > >>> otherwise which I have a feeling is never going to happen as you > >>> appear to be stuck in a loop). > >>> > >>> /Flibble > >>> > >> > >> > > > > I continue to note that you repeatedly refuse to address my point > > regarding how x86 mov instructions can read/write from/to memory > > mapped I/O rather than RAM so the result of the mov instruction > > cannot be known a priori. The halting program concerns computing > > devices and a computing device which cannot do I/O is next to > > useless, much like your decider (until you actually prove otherwise > > which I have a feeling is never going to happen as you appear to be > > stuck in a loop). > > > > /Flibble > > > > You are the only one that believes that your points have any > relevance. That you believe that data movement instructions have > anything to do with control flow proves that your points have no > relevance. You literally have no clue about what you are talking about, whatsoever. This explains everything. /Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-09 16:13 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <nIGdnZEeKNGQIXX9nZ2dnUU7-f2dnZ2d@giganews.com> |
| In reply to | #35993 |
On 7/9/2021 4:08 PM, Mr Flibble wrote:
> On Fri, 9 Jul 2021 14:24:33 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
>>> On Fri, 9 Jul 2021 12:47:12 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>> [Halt Deciding Axiom] When the pure simulation of the machine
>>>>>> description ⟨P⟩ of a machine P on its input I never halts we know
>>>>>> that P(I) never halts.
>>>>>>
>>>>>> No we cannot. In order to remove the pathological feedback loop
>>>>>> such that P does the opposite of whatever H decides H simply acts
>>>>>> as a pure simulator of P thus having no effect what-so-ever on
>>>>>> the behavior of P until after its halt status decision has been
>>>>>> made.
>>>>>
>>>>> Except your decider can only handle trivial uninteresting cases:
>>>>> if you wish to make progress on this then prove your decider works
>>>>> with a non-trivial case which includes branching logic predicated
>>>>> on arbitrary program input that is unknown a priori to the
>>>>> simulation starting; but before you even do that prove your
>>>>> decider works with a non-trivial case with branching logic
>>>>> predicated on arbitrary program input that *is* known a priori.
>>>>>
>>>>
>>>> You continue to prove to everyone that actually knows these things
>>>> that you are an ignoramus on this subject.
>>>>
>>>> That H correctly decides that all of the standard counter-examples
>>>> templates never halt eliminates the entire basis of all of the
>>>> conventional halting problem undecidability proofs.
>>>>
>>>>> I also note that you repeatedly refuse to address my point
>>>>> regarding how x86 mov instructions can read/write from/to memory
>>>>> mapped I/O rather than RAM so the result of the mov instruction
>>>>> cannot be known a priori. The halting program concerns computing
>>>>> devices and a computing device which cannot do I/O is next to
>>>>> useless, much like your decider (until you actually prove
>>>>> otherwise which I have a feeling is never going to happen as you
>>>>> appear to be stuck in a loop).
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>>
>>>
>>> I continue to note that you repeatedly refuse to address my point
>>> regarding how x86 mov instructions can read/write from/to memory
>>> mapped I/O rather than RAM so the result of the mov instruction
>>> cannot be known a priori. The halting program concerns computing
>>> devices and a computing device which cannot do I/O is next to
>>> useless, much like your decider (until you actually prove otherwise
>>> which I have a feeling is never going to happen as you appear to be
>>> stuck in a loop).
>>>
>>> /Flibble
>>>
>>
>> You are the only one that believes that your points have any
>> relevance. That you believe that data movement instructions have
>> anything to do with control flow proves that your points have no
>> relevance.
>
> You literally have no clue about what you are talking about,
> whatsoever. This explains everything.
>
> /Flibble
>
*Make sure that you read all of this especially the last line*
halt (p, i)
{
if ( program p halts on input i )
return true ; // p halts
else
return false ; // p doesn’t halt
}
Fig. 1. Pseudocode of the Halting Function
Strachey’s Impossible Program Strachey proposed a program
based on the result of an assumed halting function [2].
The way Strachey’s construction and other similar constructions
are used to show the impossibility of a decideable halting
function is quite similar to Turing’s original disproof.
But the relevant difference we want to emphasize is that
they do not explicitly assume an infinite number of possible
machines (programs) or input data, because they directly use
reductio ad absurdum to prove that both, Strachey’s construction
and the universal halting function cannot exist.
strachey ( p )
{
if ( halt (p, p) == true )
L1 : goto L1 ; // loop forever
else
return;
}
Fig. 2. Strachey’s Impossible Program
The impossibility of Strachey’s construction given in Figure 2 becomes
obvious if one tries to apply the halting function as follows:
halt(strachey, strachey)
Since in this case strachey() itself calls halt(strachey, strachey),
it is required that the direct call of halt() and the nested call
provide the same result. However, this leads to a contradiction,
whatever result halt() returns. Within this disproof there seems
to be no indication why not it could be even applied to finite-state
systems having a concrete upper bound of state space.
https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-10 12:40 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ pathological self-reference(Olcott 2004) ] |
| Message-ID | <20210710124050.00006bad@reddwarf.jmc> |
| In reply to | #35995 |
On Fri, 9 Jul 2021 16:13:48 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/9/2021 4:08 PM, Mr Flibble wrote:
> > On Fri, 9 Jul 2021 14:24:33 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/9/2021 2:16 PM, Mr Flibble wrote:
> >>> On Fri, 9 Jul 2021 12:47:12 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
> >>>>> On Fri, 9 Jul 2021 08:59:51 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>> [Halt Deciding Axiom] When the pure simulation of the machine
> >>>>>> description ⟨P⟩ of a machine P on its input I never halts we
> >>>>>> know that P(I) never halts.
> >>>>>>
> >>>>>> No we cannot. In order to remove the pathological feedback loop
> >>>>>> such that P does the opposite of whatever H decides H simply
> >>>>>> acts as a pure simulator of P thus having no effect
> >>>>>> what-so-ever on the behavior of P until after its halt status
> >>>>>> decision has been made.
> >>>>>
> >>>>> Except your decider can only handle trivial uninteresting cases:
> >>>>> if you wish to make progress on this then prove your decider
> >>>>> works with a non-trivial case which includes branching logic
> >>>>> predicated on arbitrary program input that is unknown a priori
> >>>>> to the simulation starting; but before you even do that prove
> >>>>> your decider works with a non-trivial case with branching logic
> >>>>> predicated on arbitrary program input that *is* known a priori.
> >>>>>
> >>>>
> >>>> You continue to prove to everyone that actually knows these
> >>>> things that you are an ignoramus on this subject.
> >>>>
> >>>> That H correctly decides that all of the standard
> >>>> counter-examples templates never halt eliminates the entire
> >>>> basis of all of the conventional halting problem undecidability
> >>>> proofs.
> >>>>> I also note that you repeatedly refuse to address my point
> >>>>> regarding how x86 mov instructions can read/write from/to memory
> >>>>> mapped I/O rather than RAM so the result of the mov instruction
> >>>>> cannot be known a priori. The halting program concerns computing
> >>>>> devices and a computing device which cannot do I/O is next to
> >>>>> useless, much like your decider (until you actually prove
> >>>>> otherwise which I have a feeling is never going to happen as you
> >>>>> appear to be stuck in a loop).
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>>
> >>>
> >>> I continue to note that you repeatedly refuse to address my point
> >>> regarding how x86 mov instructions can read/write from/to memory
> >>> mapped I/O rather than RAM so the result of the mov instruction
> >>> cannot be known a priori. The halting program concerns computing
> >>> devices and a computing device which cannot do I/O is next to
> >>> useless, much like your decider (until you actually prove
> >>> otherwise which I have a feeling is never going to happen as you
> >>> appear to be stuck in a loop).
> >>>
> >>> /Flibble
> >>>
> >>
> >> You are the only one that believes that your points have any
> >> relevance. That you believe that data movement instructions have
> >> anything to do with control flow proves that your points have no
> >> relevance.
> >
> > You literally have no clue about what you are talking about,
> > whatsoever. This explains everything.
> >
> > /Flibble
> >
>
> *Make sure that you read all of this especially the last line*
>
> halt (p, i)
> {
> if ( program p halts on input i )
> return true ; // p halts
> else
> return false ; // p doesn’t halt
> }
> Fig. 1. Pseudocode of the Halting Function
>
> Strachey’s Impossible Program Strachey proposed a program
> based on the result of an assumed halting function [2].
> The way Strachey’s construction and other similar constructions
> are used to show the impossibility of a decideable halting
> function is quite similar to Turing’s original disproof.
> But the relevant difference we want to emphasize is that
> they do not explicitly assume an infinite number of possible
> machines (programs) or input data, because they directly use
> reductio ad absurdum to prove that both, Strachey’s construction
> and the universal halting function cannot exist.
>
> strachey ( p )
> {
> if ( halt (p, p) == true )
> L1 : goto L1 ; // loop forever
> else
> return;
> }
>
> Fig. 2. Strachey’s Impossible Program
>
> The impossibility of Strachey’s construction given in Figure 2 becomes
> obvious if one tries to apply the halting function as follows:
>
> halt(strachey, strachey)
>
> Since in this case strachey() itself calls halt(strachey, strachey),
> it is required that the direct call of halt() and the nested call
> provide the same result. However, this leads to a contradiction,
> whatever result halt() returns. Within this disproof there seems
> to be no indication why not it could be even applied to finite-state
> systems having a concrete upper bound of state space.
>
> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
Except your decider can only handle trivial uninteresting cases: if you
wish to make progress on this then prove your decider works with a
non-trivial case which includes branching logic predicated on arbitrary
program input that is unknown a priori to the simulation starting; but
before you even do that prove your decider works with a non-trivial
case with branching logic predicated on arbitrary program input that
*is* known a priori.
I also continue to note, given your "solution" is based on simulating an
x86 machine, that you repeatedly refuse to address adequately my point
regarding how x86 mov instructions can read/write from/to memory mapped
I/O rather than RAM so the result of the mov instruction cannot be
known a priori. The halting program concerns computing devices and a
computing device which cannot do I/O is next to useless, much like your
decider (until you actually prove otherwise which I have a feeling is
never going to happen as you appear to be stuck in a loop).
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-10 08:54 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <FfSdnXqwdMIPO3T9nZ2dnUU7-XnNnZ2d@giganews.com> |
| In reply to | #36036 |
On 7/10/2021 6:40 AM, Mr Flibble wrote:
> On Fri, 9 Jul 2021 16:13:48 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/9/2021 4:08 PM, Mr Flibble wrote:
>>> On Fri, 9 Jul 2021 14:24:33 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
>>>>> On Fri, 9 Jul 2021 12:47:12 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
>>>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> [Halt Deciding Axiom] When the pure simulation of the machine
>>>>>>>> description ⟨P⟩ of a machine P on its input I never halts we
>>>>>>>> know that P(I) never halts.
>>>>>>>>
>>>>>>>> No we cannot. In order to remove the pathological feedback loop
>>>>>>>> such that P does the opposite of whatever H decides H simply
>>>>>>>> acts as a pure simulator of P thus having no effect
>>>>>>>> what-so-ever on the behavior of P until after its halt status
>>>>>>>> decision has been made.
>>>>>>>
>>>>>>> Except your decider can only handle trivial uninteresting cases:
>>>>>>> if you wish to make progress on this then prove your decider
>>>>>>> works with a non-trivial case which includes branching logic
>>>>>>> predicated on arbitrary program input that is unknown a priori
>>>>>>> to the simulation starting; but before you even do that prove
>>>>>>> your decider works with a non-trivial case with branching logic
>>>>>>> predicated on arbitrary program input that *is* known a priori.
>>>>>>>
>>>>>>
>>>>>> You continue to prove to everyone that actually knows these
>>>>>> things that you are an ignoramus on this subject.
>>>>>>
>>>>>> That H correctly decides that all of the standard
>>>>>> counter-examples templates never halt eliminates the entire
>>>>>> basis of all of the conventional halting problem undecidability
>>>>>> proofs.
>>>>>>> I also note that you repeatedly refuse to address my point
>>>>>>> regarding how x86 mov instructions can read/write from/to memory
>>>>>>> mapped I/O rather than RAM so the result of the mov instruction
>>>>>>> cannot be known a priori. The halting program concerns computing
>>>>>>> devices and a computing device which cannot do I/O is next to
>>>>>>> useless, much like your decider (until you actually prove
>>>>>>> otherwise which I have a feeling is never going to happen as you
>>>>>>> appear to be stuck in a loop).
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> I continue to note that you repeatedly refuse to address my point
>>>>> regarding how x86 mov instructions can read/write from/to memory
>>>>> mapped I/O rather than RAM so the result of the mov instruction
>>>>> cannot be known a priori. The halting program concerns computing
>>>>> devices and a computing device which cannot do I/O is next to
>>>>> useless, much like your decider (until you actually prove
>>>>> otherwise which I have a feeling is never going to happen as you
>>>>> appear to be stuck in a loop).
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> You are the only one that believes that your points have any
>>>> relevance. That you believe that data movement instructions have
>>>> anything to do with control flow proves that your points have no
>>>> relevance.
>>>
>>> You literally have no clue about what you are talking about,
>>> whatsoever. This explains everything.
>>>
>>> /Flibble
>>>
>>
>> *Make sure that you read all of this especially the last line*
>>
>> halt (p, i)
>> {
>> if ( program p halts on input i )
>> return true ; // p halts
>> else
>> return false ; // p doesn’t halt
>> }
>> Fig. 1. Pseudocode of the Halting Function
>>
>> Strachey’s Impossible Program Strachey proposed a program
>> based on the result of an assumed halting function [2].
>> The way Strachey’s construction and other similar constructions
>> are used to show the impossibility of a decideable halting
>> function is quite similar to Turing’s original disproof.
>> But the relevant difference we want to emphasize is that
>> they do not explicitly assume an infinite number of possible
>> machines (programs) or input data, because they directly use
>> reductio ad absurdum to prove that both, Strachey’s construction
>> and the universal halting function cannot exist.
>>
>> strachey ( p )
>> {
>> if ( halt (p, p) == true )
>> L1 : goto L1 ; // loop forever
>> else
>> return;
>> }
>>
>> Fig. 2. Strachey’s Impossible Program
>>
>> The impossibility of Strachey’s construction given in Figure 2 becomes
>> obvious if one tries to apply the halting function as follows:
>>
>> halt(strachey, strachey)
>>
>> Since in this case strachey() itself calls halt(strachey, strachey),
>> it is required that the direct call of halt() and the nested call
>> provide the same result. However, this leads to a contradiction,
>> whatever result halt() returns. Within this disproof there seems
>> to be no indication why not it could be even applied to finite-state
>> systems having a concrete upper bound of state space.
>>
>> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
>
> Except your decider can only handle trivial uninteresting cases: if you
Ask other people here if being able to correctly decide the strachey
case is trivial or uninteresting. Ben might be the best one to ask about
this.
Here is his original 1965 letter.
https://academic.oup.com/comjnl/article/7/4/313/354243
> wish to make progress on this then prove your decider works with a
> non-trivial case which includes branching logic predicated on arbitrary
> program input that is unknown a priori to the simulation starting; but
> before you even do that prove your decider works with a non-trivial
> case with branching logic predicated on arbitrary program input that
> *is* known a priori.
>
> I also continue to note, given your "solution" is based on simulating an
> x86 machine, that you repeatedly refuse to address adequately my point
> regarding how x86 mov instructions can read/write from/to memory mapped
> I/O rather than RAM so the result of the mov instruction cannot be
> known a priori. The halting program concerns computing devices and a
> computing device which cannot do I/O is next to useless, much like your
> decider (until you actually prove otherwise which I have a feeling is
> never going to happen as you appear to be stuck in a loop).
>
> /Flibble
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-10 15:30 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <20210710153034.0000569f@reddwarf.jmc> |
| In reply to | #36040 |
On Sat, 10 Jul 2021 08:54:23 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/10/2021 6:40 AM, Mr Flibble wrote:
> > On Fri, 9 Jul 2021 16:13:48 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/9/2021 4:08 PM, Mr Flibble wrote:
> >>> On Fri, 9 Jul 2021 14:24:33 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
> >>>>> On Fri, 9 Jul 2021 12:47:12 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
> >>>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>> [Halt Deciding Axiom] When the pure simulation of the machine
> >>>>>>>> description ⟨P⟩ of a machine P on its input I never halts we
> >>>>>>>> know that P(I) never halts.
> >>>>>>>>
> >>>>>>>> No we cannot. In order to remove the pathological feedback
> >>>>>>>> loop such that P does the opposite of whatever H decides H
> >>>>>>>> simply acts as a pure simulator of P thus having no effect
> >>>>>>>> what-so-ever on the behavior of P until after its halt status
> >>>>>>>> decision has been made.
> >>>>>>>
> >>>>>>> Except your decider can only handle trivial uninteresting
> >>>>>>> cases: if you wish to make progress on this then prove your
> >>>>>>> decider works with a non-trivial case which includes
> >>>>>>> branching logic predicated on arbitrary program input that is
> >>>>>>> unknown a priori to the simulation starting; but before you
> >>>>>>> even do that prove your decider works with a non-trivial case
> >>>>>>> with branching logic predicated on arbitrary program input
> >>>>>>> that *is* known a priori.
> >>>>>>
> >>>>>> You continue to prove to everyone that actually knows these
> >>>>>> things that you are an ignoramus on this subject.
> >>>>>>
> >>>>>> That H correctly decides that all of the standard
> >>>>>> counter-examples templates never halt eliminates the entire
> >>>>>> basis of all of the conventional halting problem undecidability
> >>>>>> proofs.
> >>>>>>> I also note that you repeatedly refuse to address my point
> >>>>>>> regarding how x86 mov instructions can read/write from/to
> >>>>>>> memory mapped I/O rather than RAM so the result of the mov
> >>>>>>> instruction cannot be known a priori. The halting program
> >>>>>>> concerns computing devices and a computing device which
> >>>>>>> cannot do I/O is next to useless, much like your decider
> >>>>>>> (until you actually prove otherwise which I have a feeling is
> >>>>>>> never going to happen as you appear to be stuck in a loop).
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>>
> >>>>>
> >>>>> I continue to note that you repeatedly refuse to address my
> >>>>> point regarding how x86 mov instructions can read/write from/to
> >>>>> memory mapped I/O rather than RAM so the result of the mov
> >>>>> instruction cannot be known a priori. The halting program
> >>>>> concerns computing devices and a computing device which cannot
> >>>>> do I/O is next to useless, much like your decider (until you
> >>>>> actually prove otherwise which I have a feeling is never going
> >>>>> to happen as you appear to be stuck in a loop).
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> You are the only one that believes that your points have any
> >>>> relevance. That you believe that data movement instructions have
> >>>> anything to do with control flow proves that your points have no
> >>>> relevance.
> >>>
> >>> You literally have no clue about what you are talking about,
> >>> whatsoever. This explains everything.
> >>>
> >>> /Flibble
> >>>
> >>
> >> *Make sure that you read all of this especially the last line*
> >>
> >> halt (p, i)
> >> {
> >> if ( program p halts on input i )
> >> return true ; // p halts
> >> else
> >> return false ; // p doesn’t halt
> >> }
> >> Fig. 1. Pseudocode of the Halting Function
> >>
> >> Strachey’s Impossible Program Strachey proposed a program
> >> based on the result of an assumed halting function [2].
> >> The way Strachey’s construction and other similar constructions
> >> are used to show the impossibility of a decideable halting
> >> function is quite similar to Turing’s original disproof.
> >> But the relevant difference we want to emphasize is that
> >> they do not explicitly assume an infinite number of possible
> >> machines (programs) or input data, because they directly use
> >> reductio ad absurdum to prove that both, Strachey’s construction
> >> and the universal halting function cannot exist.
> >>
> >> strachey ( p )
> >> {
> >> if ( halt (p, p) == true )
> >> L1 : goto L1 ; // loop forever
> >> else
> >> return;
> >> }
> >>
> >> Fig. 2. Strachey’s Impossible Program
> >>
> >> The impossibility of Strachey’s construction given in Figure 2
> >> becomes obvious if one tries to apply the halting function as
> >> follows:
> >>
> >> halt(strachey, strachey)
> >>
> >> Since in this case strachey() itself calls halt(strachey,
> >> strachey), it is required that the direct call of halt() and the
> >> nested call provide the same result. However, this leads to a
> >> contradiction, whatever result halt() returns. Within this
> >> disproof there seems to be no indication why not it could be even
> >> applied to finite-state systems having a concrete upper bound of
> >> state space.
> >>
> >> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
> >>
> >
> > Except your decider can only handle trivial uninteresting cases: if
> > you
>
> Ask other people here if being able to correctly decide the strachey
> case is trivial or uninteresting. Ben might be the best one to ask
> about this.
>
> Here is his original 1965 letter.
> https://academic.oup.com/comjnl/article/7/4/313/354243
All Strachey's letter shows is that a decider cannot be part of
that which is being decided.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-10 10:00 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <z5WdnVkIYuC5K3T9nZ2dnUU7-QvNnZ2d@giganews.com> |
| In reply to | #36042 |
On 7/10/2021 9:30 AM, Mr Flibble wrote:
> On Sat, 10 Jul 2021 08:54:23 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/10/2021 6:40 AM, Mr Flibble wrote:
>>> On Fri, 9 Jul 2021 16:13:48 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/9/2021 4:08 PM, Mr Flibble wrote:
>>>>> On Fri, 9 Jul 2021 14:24:33 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
>>>>>>> On Fri, 9 Jul 2021 12:47:12 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> [Halt Deciding Axiom] When the pure simulation of the machine
>>>>>>>>>> description ⟨P⟩ of a machine P on its input I never halts we
>>>>>>>>>> know that P(I) never halts.
>>>>>>>>>>
>>>>>>>>>> No we cannot. In order to remove the pathological feedback
>>>>>>>>>> loop such that P does the opposite of whatever H decides H
>>>>>>>>>> simply acts as a pure simulator of P thus having no effect
>>>>>>>>>> what-so-ever on the behavior of P until after its halt status
>>>>>>>>>> decision has been made.
>>>>>>>>>
>>>>>>>>> Except your decider can only handle trivial uninteresting
>>>>>>>>> cases: if you wish to make progress on this then prove your
>>>>>>>>> decider works with a non-trivial case which includes
>>>>>>>>> branching logic predicated on arbitrary program input that is
>>>>>>>>> unknown a priori to the simulation starting; but before you
>>>>>>>>> even do that prove your decider works with a non-trivial case
>>>>>>>>> with branching logic predicated on arbitrary program input
>>>>>>>>> that *is* known a priori.
>>>>>>>>
>>>>>>>> You continue to prove to everyone that actually knows these
>>>>>>>> things that you are an ignoramus on this subject.
>>>>>>>>
>>>>>>>> That H correctly decides that all of the standard
>>>>>>>> counter-examples templates never halt eliminates the entire
>>>>>>>> basis of all of the conventional halting problem undecidability
>>>>>>>> proofs.
>>>>>>>>> I also note that you repeatedly refuse to address my point
>>>>>>>>> regarding how x86 mov instructions can read/write from/to
>>>>>>>>> memory mapped I/O rather than RAM so the result of the mov
>>>>>>>>> instruction cannot be known a priori. The halting program
>>>>>>>>> concerns computing devices and a computing device which
>>>>>>>>> cannot do I/O is next to useless, much like your decider
>>>>>>>>> (until you actually prove otherwise which I have a feeling is
>>>>>>>>> never going to happen as you appear to be stuck in a loop).
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> I continue to note that you repeatedly refuse to address my
>>>>>>> point regarding how x86 mov instructions can read/write from/to
>>>>>>> memory mapped I/O rather than RAM so the result of the mov
>>>>>>> instruction cannot be known a priori. The halting program
>>>>>>> concerns computing devices and a computing device which cannot
>>>>>>> do I/O is next to useless, much like your decider (until you
>>>>>>> actually prove otherwise which I have a feeling is never going
>>>>>>> to happen as you appear to be stuck in a loop).
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> You are the only one that believes that your points have any
>>>>>> relevance. That you believe that data movement instructions have
>>>>>> anything to do with control flow proves that your points have no
>>>>>> relevance.
>>>>>
>>>>> You literally have no clue about what you are talking about,
>>>>> whatsoever. This explains everything.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> *Make sure that you read all of this especially the last line*
>>>>
>>>> halt (p, i)
>>>> {
>>>> if ( program p halts on input i )
>>>> return true ; // p halts
>>>> else
>>>> return false ; // p doesn’t halt
>>>> }
>>>> Fig. 1. Pseudocode of the Halting Function
>>>>
>>>> Strachey’s Impossible Program Strachey proposed a program
>>>> based on the result of an assumed halting function [2].
>>>> The way Strachey’s construction and other similar constructions
>>>> are used to show the impossibility of a decideable halting
>>>> function is quite similar to Turing’s original disproof.
>>>> But the relevant difference we want to emphasize is that
>>>> they do not explicitly assume an infinite number of possible
>>>> machines (programs) or input data, because they directly use
>>>> reductio ad absurdum to prove that both, Strachey’s construction
>>>> and the universal halting function cannot exist.
>>>>
>>>> strachey ( p )
>>>> {
>>>> if ( halt (p, p) == true )
>>>> L1 : goto L1 ; // loop forever
>>>> else
>>>> return;
>>>> }
>>>>
>>>> Fig. 2. Strachey’s Impossible Program
>>>>
>>>> The impossibility of Strachey’s construction given in Figure 2
>>>> becomes obvious if one tries to apply the halting function as
>>>> follows:
>>>>
>>>> halt(strachey, strachey)
>>>>
>>>> Since in this case strachey() itself calls halt(strachey,
>>>> strachey), it is required that the direct call of halt() and the
>>>> nested call provide the same result. However, this leads to a
>>>> contradiction, whatever result halt() returns. Within this
>>>> disproof there seems to be no indication why not it could be even
>>>> applied to finite-state systems having a concrete upper bound of
>>>> state space.
>>>>
>>>> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
>>>>
>>>
>>> Except your decider can only handle trivial uninteresting cases: if
>>> you
>>
>> Ask other people here if being able to correctly decide the strachey
>> case is trivial or uninteresting. Ben might be the best one to ask
>> about this.
>>
>> Here is his original 1965 letter.
>> https://academic.oup.com/comjnl/article/7/4/313/354243
>
> All Strachey's letter shows is that a decider cannot be part of
> that which is being decided.
>
> /Flibble
>
// Simplified Linz Ĥ (Linz:1990:319)
void P(u32 x)
{
u32 Input_Halts = H(x, x);
if (Input_Halts)
HERE: goto HERE;
}
int main()
{
u32 Input_Halts = H((u32)P, (u32)P);
Output("Input_Halts = ", Input_Halts);
}
What it shows is that the halting problem proof can be enormously
simplified to the impossibility of the H(P,P) in main() returning a
correct halt status value to main().
*Here are Strachey's (verbatim) own words*
Suppose T[R] is a Boolean function taking a routine
(or program) R with no formal or free variables as its
argument and that for all R, T[R] — True if R terminates
if run and that T[R] = False if R does not terminate.
Consider the routine P defined as follows
rec routine P
§L:if T[P] go to L
Return §
If T[P] = True the routine P will loop, and it will
only terminate if T[P] = False. In each case T[P] has
exactly the wrong value, and this contradiction shows
that the function T cannot exist.
Strachey is the creator of CPL ancestor to BCPL then B then C
His code above is written in his CPL programming language.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-10 16:15 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <20210710161537.00002347@reddwarf.jmc> |
| In reply to | #36045 |
On Sat, 10 Jul 2021 10:00:51 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/10/2021 9:30 AM, Mr Flibble wrote:
> > On Sat, 10 Jul 2021 08:54:23 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/10/2021 6:40 AM, Mr Flibble wrote:
> >>> On Fri, 9 Jul 2021 16:13:48 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/9/2021 4:08 PM, Mr Flibble wrote:
> >>>>> On Fri, 9 Jul 2021 14:24:33 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
> >>>>>>> On Fri, 9 Jul 2021 12:47:12 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>> [Halt Deciding Axiom] When the pure simulation of the
> >>>>>>>>>> machine description ⟨P⟩ of a machine P on its input I
> >>>>>>>>>> never halts we know that P(I) never halts.
> >>>>>>>>>>
> >>>>>>>>>> No we cannot. In order to remove the pathological feedback
> >>>>>>>>>> loop such that P does the opposite of whatever H decides H
> >>>>>>>>>> simply acts as a pure simulator of P thus having no effect
> >>>>>>>>>> what-so-ever on the behavior of P until after its halt
> >>>>>>>>>> status decision has been made.
> >>>>>>>>>
> >>>>>>>>> Except your decider can only handle trivial uninteresting
> >>>>>>>>> cases: if you wish to make progress on this then prove your
> >>>>>>>>> decider works with a non-trivial case which includes
> >>>>>>>>> branching logic predicated on arbitrary program input that
> >>>>>>>>> is unknown a priori to the simulation starting; but before
> >>>>>>>>> you even do that prove your decider works with a
> >>>>>>>>> non-trivial case with branching logic predicated on
> >>>>>>>>> arbitrary program input that *is* known a priori.
> >>>>>>>>
> >>>>>>>> You continue to prove to everyone that actually knows these
> >>>>>>>> things that you are an ignoramus on this subject.
> >>>>>>>>
> >>>>>>>> That H correctly decides that all of the standard
> >>>>>>>> counter-examples templates never halt eliminates the entire
> >>>>>>>> basis of all of the conventional halting problem
> >>>>>>>> undecidability proofs.
> >>>>>>>>> I also note that you repeatedly refuse to address my point
> >>>>>>>>> regarding how x86 mov instructions can read/write from/to
> >>>>>>>>> memory mapped I/O rather than RAM so the result of the mov
> >>>>>>>>> instruction cannot be known a priori. The halting program
> >>>>>>>>> concerns computing devices and a computing device which
> >>>>>>>>> cannot do I/O is next to useless, much like your decider
> >>>>>>>>> (until you actually prove otherwise which I have a feeling
> >>>>>>>>> is never going to happen as you appear to be stuck in a
> >>>>>>>>> loop).
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>
> >>>>>>> I continue to note that you repeatedly refuse to address my
> >>>>>>> point regarding how x86 mov instructions can read/write
> >>>>>>> from/to memory mapped I/O rather than RAM so the result of
> >>>>>>> the mov instruction cannot be known a priori. The halting
> >>>>>>> program concerns computing devices and a computing device
> >>>>>>> which cannot do I/O is next to useless, much like your
> >>>>>>> decider (until you actually prove otherwise which I have a
> >>>>>>> feeling is never going to happen as you appear to be stuck in
> >>>>>>> a loop).
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> You are the only one that believes that your points have any
> >>>>>> relevance. That you believe that data movement instructions
> >>>>>> have anything to do with control flow proves that your points
> >>>>>> have no relevance.
> >>>>>
> >>>>> You literally have no clue about what you are talking about,
> >>>>> whatsoever. This explains everything.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> *Make sure that you read all of this especially the last line*
> >>>>
> >>>> halt (p, i)
> >>>> {
> >>>> if ( program p halts on input i )
> >>>> return true ; // p halts
> >>>> else
> >>>> return false ; // p doesn’t halt
> >>>> }
> >>>> Fig. 1. Pseudocode of the Halting Function
> >>>>
> >>>> Strachey’s Impossible Program Strachey proposed a program
> >>>> based on the result of an assumed halting function [2].
> >>>> The way Strachey’s construction and other similar constructions
> >>>> are used to show the impossibility of a decideable halting
> >>>> function is quite similar to Turing’s original disproof.
> >>>> But the relevant difference we want to emphasize is that
> >>>> they do not explicitly assume an infinite number of possible
> >>>> machines (programs) or input data, because they directly use
> >>>> reductio ad absurdum to prove that both, Strachey’s construction
> >>>> and the universal halting function cannot exist.
> >>>>
> >>>> strachey ( p )
> >>>> {
> >>>> if ( halt (p, p) == true )
> >>>> L1 : goto L1 ; // loop forever
> >>>> else
> >>>> return;
> >>>> }
> >>>>
> >>>> Fig. 2. Strachey’s Impossible Program
> >>>>
> >>>> The impossibility of Strachey’s construction given in Figure 2
> >>>> becomes obvious if one tries to apply the halting function as
> >>>> follows:
> >>>>
> >>>> halt(strachey, strachey)
> >>>>
> >>>> Since in this case strachey() itself calls halt(strachey,
> >>>> strachey), it is required that the direct call of halt() and the
> >>>> nested call provide the same result. However, this leads to a
> >>>> contradiction, whatever result halt() returns. Within this
> >>>> disproof there seems to be no indication why not it could be even
> >>>> applied to finite-state systems having a concrete upper bound of
> >>>> state space.
> >>>>
> >>>> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
> >>>>
> >>>
> >>> Except your decider can only handle trivial uninteresting cases:
> >>> if you
> >>
> >> Ask other people here if being able to correctly decide the
> >> strachey case is trivial or uninteresting. Ben might be the best
> >> one to ask about this.
> >>
> >> Here is his original 1965 letter.
> >> https://academic.oup.com/comjnl/article/7/4/313/354243
> >
> > All Strachey's letter shows is that a decider cannot be part of
> > that which is being decided.
> >
> > /Flibble
> >
>
>
> // Simplified Linz Ĥ (Linz:1990:319)
> void P(u32 x)
> {
> u32 Input_Halts = H(x, x);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
> int main()
> {
> u32 Input_Halts = H((u32)P, (u32)P);
> Output("Input_Halts = ", Input_Halts);
> }
>
> What it shows is that the halting problem proof can be enormously
> simplified to the impossibility of the H(P,P) in main() returning a
> correct halt status value to main().
>
> *Here are Strachey's (verbatim) own words*
> Suppose T[R] is a Boolean function taking a routine
> (or program) R with no formal or free variables as its
> argument and that for all R, T[R] — True if R terminates
> if run and that T[R] = False if R does not terminate.
> Consider the routine P defined as follows
>
> rec routine P
> §L:if T[P] go to L
> Return §
>
> If T[P] = True the routine P will loop, and it will
> only terminate if T[P] = False. In each case T[P] has
> exactly the wrong value, and this contradiction shows
> that the function T cannot exist.
>
> Strachey is the creator of CPL ancestor to BCPL then B then C
> His code above is written in his CPL programming language.
I repeat: all Strachey's letter shows is that a decider cannot be part
of that which is being decided.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-10 10:21 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <j_GdncmJqZZqJ3T9nZ2dnUU7-R-dnZ2d@giganews.com> |
| In reply to | #36048 |
On 7/10/2021 10:15 AM, Mr Flibble wrote:
> On Sat, 10 Jul 2021 10:00:51 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/10/2021 9:30 AM, Mr Flibble wrote:
>>> On Sat, 10 Jul 2021 08:54:23 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/10/2021 6:40 AM, Mr Flibble wrote:
>>>>> On Fri, 9 Jul 2021 16:13:48 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 7/9/2021 4:08 PM, Mr Flibble wrote:
>>>>>>> On Fri, 9 Jul 2021 14:24:33 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 9 Jul 2021 12:47:12 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> [Halt Deciding Axiom] When the pure simulation of the
>>>>>>>>>>>> machine description ⟨P⟩ of a machine P on its input I
>>>>>>>>>>>> never halts we know that P(I) never halts.
>>>>>>>>>>>>
>>>>>>>>>>>> No we cannot. In order to remove the pathological feedback
>>>>>>>>>>>> loop such that P does the opposite of whatever H decides H
>>>>>>>>>>>> simply acts as a pure simulator of P thus having no effect
>>>>>>>>>>>> what-so-ever on the behavior of P until after its halt
>>>>>>>>>>>> status decision has been made.
>>>>>>>>>>>
>>>>>>>>>>> Except your decider can only handle trivial uninteresting
>>>>>>>>>>> cases: if you wish to make progress on this then prove your
>>>>>>>>>>> decider works with a non-trivial case which includes
>>>>>>>>>>> branching logic predicated on arbitrary program input that
>>>>>>>>>>> is unknown a priori to the simulation starting; but before
>>>>>>>>>>> you even do that prove your decider works with a
>>>>>>>>>>> non-trivial case with branching logic predicated on
>>>>>>>>>>> arbitrary program input that *is* known a priori.
>>>>>>>>>>
>>>>>>>>>> You continue to prove to everyone that actually knows these
>>>>>>>>>> things that you are an ignoramus on this subject.
>>>>>>>>>>
>>>>>>>>>> That H correctly decides that all of the standard
>>>>>>>>>> counter-examples templates never halt eliminates the entire
>>>>>>>>>> basis of all of the conventional halting problem
>>>>>>>>>> undecidability proofs.
>>>>>>>>>>> I also note that you repeatedly refuse to address my point
>>>>>>>>>>> regarding how x86 mov instructions can read/write from/to
>>>>>>>>>>> memory mapped I/O rather than RAM so the result of the mov
>>>>>>>>>>> instruction cannot be known a priori. The halting program
>>>>>>>>>>> concerns computing devices and a computing device which
>>>>>>>>>>> cannot do I/O is next to useless, much like your decider
>>>>>>>>>>> (until you actually prove otherwise which I have a feeling
>>>>>>>>>>> is never going to happen as you appear to be stuck in a
>>>>>>>>>>> loop).
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I continue to note that you repeatedly refuse to address my
>>>>>>>>> point regarding how x86 mov instructions can read/write
>>>>>>>>> from/to memory mapped I/O rather than RAM so the result of
>>>>>>>>> the mov instruction cannot be known a priori. The halting
>>>>>>>>> program concerns computing devices and a computing device
>>>>>>>>> which cannot do I/O is next to useless, much like your
>>>>>>>>> decider (until you actually prove otherwise which I have a
>>>>>>>>> feeling is never going to happen as you appear to be stuck in
>>>>>>>>> a loop).
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> You are the only one that believes that your points have any
>>>>>>>> relevance. That you believe that data movement instructions
>>>>>>>> have anything to do with control flow proves that your points
>>>>>>>> have no relevance.
>>>>>>>
>>>>>>> You literally have no clue about what you are talking about,
>>>>>>> whatsoever. This explains everything.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> *Make sure that you read all of this especially the last line*
>>>>>>
>>>>>> halt (p, i)
>>>>>> {
>>>>>> if ( program p halts on input i )
>>>>>> return true ; // p halts
>>>>>> else
>>>>>> return false ; // p doesn’t halt
>>>>>> }
>>>>>> Fig. 1. Pseudocode of the Halting Function
>>>>>>
>>>>>> Strachey’s Impossible Program Strachey proposed a program
>>>>>> based on the result of an assumed halting function [2].
>>>>>> The way Strachey’s construction and other similar constructions
>>>>>> are used to show the impossibility of a decideable halting
>>>>>> function is quite similar to Turing’s original disproof.
>>>>>> But the relevant difference we want to emphasize is that
>>>>>> they do not explicitly assume an infinite number of possible
>>>>>> machines (programs) or input data, because they directly use
>>>>>> reductio ad absurdum to prove that both, Strachey’s construction
>>>>>> and the universal halting function cannot exist.
>>>>>>
>>>>>> strachey ( p )
>>>>>> {
>>>>>> if ( halt (p, p) == true )
>>>>>> L1 : goto L1 ; // loop forever
>>>>>> else
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> Fig. 2. Strachey’s Impossible Program
>>>>>>
>>>>>> The impossibility of Strachey’s construction given in Figure 2
>>>>>> becomes obvious if one tries to apply the halting function as
>>>>>> follows:
>>>>>>
>>>>>> halt(strachey, strachey)
>>>>>>
>>>>>> Since in this case strachey() itself calls halt(strachey,
>>>>>> strachey), it is required that the direct call of halt() and the
>>>>>> nested call provide the same result. However, this leads to a
>>>>>> contradiction, whatever result halt() returns. Within this
>>>>>> disproof there seems to be no indication why not it could be even
>>>>>> applied to finite-state systems having a concrete upper bound of
>>>>>> state space.
>>>>>>
>>>>>> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
>>>>>>
>>>>>
>>>>> Except your decider can only handle trivial uninteresting cases:
>>>>> if you
>>>>
>>>> Ask other people here if being able to correctly decide the
>>>> strachey case is trivial or uninteresting. Ben might be the best
>>>> one to ask about this.
>>>>
>>>> Here is his original 1965 letter.
>>>> https://academic.oup.com/comjnl/article/7/4/313/354243
>>>
>>> All Strachey's letter shows is that a decider cannot be part of
>>> that which is being decided.
>>>
>>> /Flibble
>>>
>>
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> void P(u32 x)
>> {
>> u32 Input_Halts = H(x, x);
>> if (Input_Halts)
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> u32 Input_Halts = H((u32)P, (u32)P);
>> Output("Input_Halts = ", Input_Halts);
>> }
>>
>> What it shows is that the halting problem proof can be enormously
>> simplified to the impossibility of the H(P,P) in main() returning a
>> correct halt status value to main().
>>
>> *Here are Strachey's (verbatim) own words*
>> Suppose T[R] is a Boolean function taking a routine
>> (or program) R with no formal or free variables as its
>> argument and that for all R, T[R] — True if R terminates
>> if run and that T[R] = False if R does not terminate.
>> Consider the routine P defined as follows
>>
>> rec routine P
>> §L:if T[P] go to L
>> Return §
>>
>> If T[P] = True the routine P will loop, and it will
>> only terminate if T[P] = False. In each case T[P] has
>> exactly the wrong value, and this contradiction shows
>> that the function T cannot exist.
>>
>> Strachey is the creator of CPL ancestor to BCPL then B then C
>> His code above is written in his CPL programming language.
>
> I repeat: all Strachey's letter shows is that a decider cannot be part
> of that which is being decided.
>
> /Flibble
>
Although this <is> one way of putting it, all of the halting problem
proofs require that the decider is a part of what is being decided. When
we disallow that all of these proofs lose their entire basis and fail to
prove anything.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-10 16:25 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <20210710162549.000014b6@reddwarf.jmc> |
| In reply to | #36049 |
On Sat, 10 Jul 2021 10:21:26 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/10/2021 10:15 AM, Mr Flibble wrote:
> > On Sat, 10 Jul 2021 10:00:51 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/10/2021 9:30 AM, Mr Flibble wrote:
> >>> On Sat, 10 Jul 2021 08:54:23 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/10/2021 6:40 AM, Mr Flibble wrote:
> >>>>> On Fri, 9 Jul 2021 16:13:48 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 7/9/2021 4:08 PM, Mr Flibble wrote:
> >>>>>>> On Fri, 9 Jul 2021 14:24:33 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 9 Jul 2021 12:47:12 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>> [Halt Deciding Axiom] When the pure simulation of the
> >>>>>>>>>>>> machine description ⟨P⟩ of a machine P on its input I
> >>>>>>>>>>>> never halts we know that P(I) never halts.
> >>>>>>>>>>>>
> >>>>>>>>>>>> No we cannot. In order to remove the pathological
> >>>>>>>>>>>> feedback loop such that P does the opposite of whatever
> >>>>>>>>>>>> H decides H simply acts as a pure simulator of P thus
> >>>>>>>>>>>> having no effect what-so-ever on the behavior of P until
> >>>>>>>>>>>> after its halt status decision has been made.
> >>>>>>>>>>>
> >>>>>>>>>>> Except your decider can only handle trivial uninteresting
> >>>>>>>>>>> cases: if you wish to make progress on this then prove
> >>>>>>>>>>> your decider works with a non-trivial case which includes
> >>>>>>>>>>> branching logic predicated on arbitrary program input that
> >>>>>>>>>>> is unknown a priori to the simulation starting; but before
> >>>>>>>>>>> you even do that prove your decider works with a
> >>>>>>>>>>> non-trivial case with branching logic predicated on
> >>>>>>>>>>> arbitrary program input that *is* known a priori.
> >>>>>>>>>>
> >>>>>>>>>> You continue to prove to everyone that actually knows these
> >>>>>>>>>> things that you are an ignoramus on this subject.
> >>>>>>>>>>
> >>>>>>>>>> That H correctly decides that all of the standard
> >>>>>>>>>> counter-examples templates never halt eliminates the entire
> >>>>>>>>>> basis of all of the conventional halting problem
> >>>>>>>>>> undecidability proofs.
> >>>>>>>>>>> I also note that you repeatedly refuse to address my point
> >>>>>>>>>>> regarding how x86 mov instructions can read/write from/to
> >>>>>>>>>>> memory mapped I/O rather than RAM so the result of the mov
> >>>>>>>>>>> instruction cannot be known a priori. The halting program
> >>>>>>>>>>> concerns computing devices and a computing device which
> >>>>>>>>>>> cannot do I/O is next to useless, much like your decider
> >>>>>>>>>>> (until you actually prove otherwise which I have a feeling
> >>>>>>>>>>> is never going to happen as you appear to be stuck in a
> >>>>>>>>>>> loop).
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> I continue to note that you repeatedly refuse to address my
> >>>>>>>>> point regarding how x86 mov instructions can read/write
> >>>>>>>>> from/to memory mapped I/O rather than RAM so the result of
> >>>>>>>>> the mov instruction cannot be known a priori. The halting
> >>>>>>>>> program concerns computing devices and a computing device
> >>>>>>>>> which cannot do I/O is next to useless, much like your
> >>>>>>>>> decider (until you actually prove otherwise which I have a
> >>>>>>>>> feeling is never going to happen as you appear to be stuck
> >>>>>>>>> in a loop).
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> You are the only one that believes that your points have any
> >>>>>>>> relevance. That you believe that data movement instructions
> >>>>>>>> have anything to do with control flow proves that your points
> >>>>>>>> have no relevance.
> >>>>>>>
> >>>>>>> You literally have no clue about what you are talking about,
> >>>>>>> whatsoever. This explains everything.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> *Make sure that you read all of this especially the last line*
> >>>>>>
> >>>>>> halt (p, i)
> >>>>>> {
> >>>>>> if ( program p halts on input i )
> >>>>>> return true ; // p halts
> >>>>>> else
> >>>>>> return false ; // p doesn’t halt
> >>>>>> }
> >>>>>> Fig. 1. Pseudocode of the Halting Function
> >>>>>>
> >>>>>> Strachey’s Impossible Program Strachey proposed a program
> >>>>>> based on the result of an assumed halting function [2].
> >>>>>> The way Strachey’s construction and other similar constructions
> >>>>>> are used to show the impossibility of a decideable halting
> >>>>>> function is quite similar to Turing’s original disproof.
> >>>>>> But the relevant difference we want to emphasize is that
> >>>>>> they do not explicitly assume an infinite number of possible
> >>>>>> machines (programs) or input data, because they directly use
> >>>>>> reductio ad absurdum to prove that both, Strachey’s
> >>>>>> construction and the universal halting function cannot exist.
> >>>>>>
> >>>>>> strachey ( p )
> >>>>>> {
> >>>>>> if ( halt (p, p) == true )
> >>>>>> L1 : goto L1 ; // loop forever
> >>>>>> else
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> Fig. 2. Strachey’s Impossible Program
> >>>>>>
> >>>>>> The impossibility of Strachey’s construction given in Figure 2
> >>>>>> becomes obvious if one tries to apply the halting function as
> >>>>>> follows:
> >>>>>>
> >>>>>> halt(strachey, strachey)
> >>>>>>
> >>>>>> Since in this case strachey() itself calls halt(strachey,
> >>>>>> strachey), it is required that the direct call of halt() and
> >>>>>> the nested call provide the same result. However, this leads
> >>>>>> to a contradiction, whatever result halt() returns. Within this
> >>>>>> disproof there seems to be no indication why not it could be
> >>>>>> even applied to finite-state systems having a concrete upper
> >>>>>> bound of state space.
> >>>>>>
> >>>>>> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
> >>>>>>
> >>>>>
> >>>>> Except your decider can only handle trivial uninteresting cases:
> >>>>> if you
> >>>>
> >>>> Ask other people here if being able to correctly decide the
> >>>> strachey case is trivial or uninteresting. Ben might be the best
> >>>> one to ask about this.
> >>>>
> >>>> Here is his original 1965 letter.
> >>>> https://academic.oup.com/comjnl/article/7/4/313/354243
> >>>
> >>> All Strachey's letter shows is that a decider cannot be part of
> >>> that which is being decided.
> >>>
> >>> /Flibble
> >>>
> >>
> >>
> >> // Simplified Linz Ĥ (Linz:1990:319)
> >> void P(u32 x)
> >> {
> >> u32 Input_Halts = H(x, x);
> >> if (Input_Halts)
> >> HERE: goto HERE;
> >> }
> >>
> >> int main()
> >> {
> >> u32 Input_Halts = H((u32)P, (u32)P);
> >> Output("Input_Halts = ", Input_Halts);
> >> }
> >>
> >> What it shows is that the halting problem proof can be enormously
> >> simplified to the impossibility of the H(P,P) in main() returning a
> >> correct halt status value to main().
> >>
> >> *Here are Strachey's (verbatim) own words*
> >> Suppose T[R] is a Boolean function taking a routine
> >> (or program) R with no formal or free variables as its
> >> argument and that for all R, T[R] — True if R terminates
> >> if run and that T[R] = False if R does not terminate.
> >> Consider the routine P defined as follows
> >>
> >> rec routine P
> >> §L:if T[P] go to L
> >> Return §
> >>
> >> If T[P] = True the routine P will loop, and it will
> >> only terminate if T[P] = False. In each case T[P] has
> >> exactly the wrong value, and this contradiction shows
> >> that the function T cannot exist.
> >>
> >> Strachey is the creator of CPL ancestor to BCPL then B then C
> >> His code above is written in his CPL programming language.
> >
> > I repeat: all Strachey's letter shows is that a decider cannot be
> > part of that which is being decided.
> >
> > /Flibble
> >
>
> Although this <is> one way of putting it, all of the halting problem
> proofs require that the decider is a part of what is being decided.
> When we disallow that all of these proofs lose their entire basis and
> fail to prove anything.
I agree, if these proofs do require a decider to be part of that which
is being decided then they are indeed invalid for the reason Strachey
highlights in his letter.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-10 08:30 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <9de2eb0d-419f-472f-8abf-ebcc167a7646n@googlegroups.com> |
| In reply to | #36051 |
/*theObserverSystemCore(p,g);*/ is my initial decider that initially does nothing in Lessone called upon every backtrack assumption in pspace solver bob
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-10 16:33 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <20210710163304.00001a99@reddwarf.jmc> |
| In reply to | #36052 |
On Sat, 10 Jul 2021 08:30:15 -0700 (PDT) Daniel Pehoushek <pehoushek1@gmail.com> wrote: > /*theObserverSystemCore(p,g);*/ > is my initial decider that > initially does nothing > in Lessone called > upon every > backtrack > assumption > in pspace solver bob Either: a) get a better hobby, or b) take your medication. /Flibble
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-10 08:34 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <93539fca-24f6-49b6-9589-108bd2a9e59an@googlegroups.com> |
| In reply to | #36052 |
in the model counting competition cpu time is the commonly used horrible decider i am trying to educate them
[toc] | [prev] | [next] | [standalone]
| From | Daniel Pehoushek <pehoushek1@gmail.com> |
|---|---|
| Date | 2021-07-10 08:45 -0700 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <b3b9792f-c4a2-48c5-b879-d36c421749f0n@googlegroups.com> |
| In reply to | #36055 |
i am beginning to believe that in the #P competition (track 1 mc2021) the entrants may be entirely missing any small formula regression suites of benchmarks to believe in to have faith in to be assured that the slightest code change still has invariant truth on the tinest formulas benchmark suites
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-10 11:08 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <xcCdnY7hb5meW3T9nZ2dnUU7-d3NnZ2d@giganews.com> |
| In reply to | #36051 |
On 7/10/2021 10:25 AM, Mr Flibble wrote:
> On Sat, 10 Jul 2021 10:21:26 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/10/2021 10:15 AM, Mr Flibble wrote:
>>> On Sat, 10 Jul 2021 10:00:51 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/10/2021 9:30 AM, Mr Flibble wrote:
>>>>> On Sat, 10 Jul 2021 08:54:23 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 7/10/2021 6:40 AM, Mr Flibble wrote:
>>>>>>> On Fri, 9 Jul 2021 16:13:48 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 7/9/2021 4:08 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 9 Jul 2021 14:24:33 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 9 Jul 2021 12:47:12 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>> [Halt Deciding Axiom] When the pure simulation of the
>>>>>>>>>>>>>> machine description ⟨P⟩ of a machine P on its input I
>>>>>>>>>>>>>> never halts we know that P(I) never halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No we cannot. In order to remove the pathological
>>>>>>>>>>>>>> feedback loop such that P does the opposite of whatever
>>>>>>>>>>>>>> H decides H simply acts as a pure simulator of P thus
>>>>>>>>>>>>>> having no effect what-so-ever on the behavior of P until
>>>>>>>>>>>>>> after its halt status decision has been made.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except your decider can only handle trivial uninteresting
>>>>>>>>>>>>> cases: if you wish to make progress on this then prove
>>>>>>>>>>>>> your decider works with a non-trivial case which includes
>>>>>>>>>>>>> branching logic predicated on arbitrary program input that
>>>>>>>>>>>>> is unknown a priori to the simulation starting; but before
>>>>>>>>>>>>> you even do that prove your decider works with a
>>>>>>>>>>>>> non-trivial case with branching logic predicated on
>>>>>>>>>>>>> arbitrary program input that *is* known a priori.
>>>>>>>>>>>>
>>>>>>>>>>>> You continue to prove to everyone that actually knows these
>>>>>>>>>>>> things that you are an ignoramus on this subject.
>>>>>>>>>>>>
>>>>>>>>>>>> That H correctly decides that all of the standard
>>>>>>>>>>>> counter-examples templates never halt eliminates the entire
>>>>>>>>>>>> basis of all of the conventional halting problem
>>>>>>>>>>>> undecidability proofs.
>>>>>>>>>>>>> I also note that you repeatedly refuse to address my point
>>>>>>>>>>>>> regarding how x86 mov instructions can read/write from/to
>>>>>>>>>>>>> memory mapped I/O rather than RAM so the result of the mov
>>>>>>>>>>>>> instruction cannot be known a priori. The halting program
>>>>>>>>>>>>> concerns computing devices and a computing device which
>>>>>>>>>>>>> cannot do I/O is next to useless, much like your decider
>>>>>>>>>>>>> (until you actually prove otherwise which I have a feeling
>>>>>>>>>>>>> is never going to happen as you appear to be stuck in a
>>>>>>>>>>>>> loop).
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I continue to note that you repeatedly refuse to address my
>>>>>>>>>>> point regarding how x86 mov instructions can read/write
>>>>>>>>>>> from/to memory mapped I/O rather than RAM so the result of
>>>>>>>>>>> the mov instruction cannot be known a priori. The halting
>>>>>>>>>>> program concerns computing devices and a computing device
>>>>>>>>>>> which cannot do I/O is next to useless, much like your
>>>>>>>>>>> decider (until you actually prove otherwise which I have a
>>>>>>>>>>> feeling is never going to happen as you appear to be stuck
>>>>>>>>>>> in a loop).
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You are the only one that believes that your points have any
>>>>>>>>>> relevance. That you believe that data movement instructions
>>>>>>>>>> have anything to do with control flow proves that your points
>>>>>>>>>> have no relevance.
>>>>>>>>>
>>>>>>>>> You literally have no clue about what you are talking about,
>>>>>>>>> whatsoever. This explains everything.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> *Make sure that you read all of this especially the last line*
>>>>>>>>
>>>>>>>> halt (p, i)
>>>>>>>> {
>>>>>>>> if ( program p halts on input i )
>>>>>>>> return true ; // p halts
>>>>>>>> else
>>>>>>>> return false ; // p doesn’t halt
>>>>>>>> }
>>>>>>>> Fig. 1. Pseudocode of the Halting Function
>>>>>>>>
>>>>>>>> Strachey’s Impossible Program Strachey proposed a program
>>>>>>>> based on the result of an assumed halting function [2].
>>>>>>>> The way Strachey’s construction and other similar constructions
>>>>>>>> are used to show the impossibility of a decideable halting
>>>>>>>> function is quite similar to Turing’s original disproof.
>>>>>>>> But the relevant difference we want to emphasize is that
>>>>>>>> they do not explicitly assume an infinite number of possible
>>>>>>>> machines (programs) or input data, because they directly use
>>>>>>>> reductio ad absurdum to prove that both, Strachey’s
>>>>>>>> construction and the universal halting function cannot exist.
>>>>>>>>
>>>>>>>> strachey ( p )
>>>>>>>> {
>>>>>>>> if ( halt (p, p) == true )
>>>>>>>> L1 : goto L1 ; // loop forever
>>>>>>>> else
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> Fig. 2. Strachey’s Impossible Program
>>>>>>>>
>>>>>>>> The impossibility of Strachey’s construction given in Figure 2
>>>>>>>> becomes obvious if one tries to apply the halting function as
>>>>>>>> follows:
>>>>>>>>
>>>>>>>> halt(strachey, strachey)
>>>>>>>>
>>>>>>>> Since in this case strachey() itself calls halt(strachey,
>>>>>>>> strachey), it is required that the direct call of halt() and
>>>>>>>> the nested call provide the same result. However, this leads
>>>>>>>> to a contradiction, whatever result halt() returns. Within this
>>>>>>>> disproof there seems to be no indication why not it could be
>>>>>>>> even applied to finite-state systems having a concrete upper
>>>>>>>> bound of state space.
>>>>>>>>
>>>>>>>> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
>>>>>>>>
>>>>>>>
>>>>>>> Except your decider can only handle trivial uninteresting cases:
>>>>>>> if you
>>>>>>
>>>>>> Ask other people here if being able to correctly decide the
>>>>>> strachey case is trivial or uninteresting. Ben might be the best
>>>>>> one to ask about this.
>>>>>>
>>>>>> Here is his original 1965 letter.
>>>>>> https://academic.oup.com/comjnl/article/7/4/313/354243
>>>>>
>>>>> All Strachey's letter shows is that a decider cannot be part of
>>>>> that which is being decided.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>>
>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>> void P(u32 x)
>>>> {
>>>> u32 Input_Halts = H(x, x);
>>>> if (Input_Halts)
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> u32 Input_Halts = H((u32)P, (u32)P);
>>>> Output("Input_Halts = ", Input_Halts);
>>>> }
>>>>
>>>> What it shows is that the halting problem proof can be enormously
>>>> simplified to the impossibility of the H(P,P) in main() returning a
>>>> correct halt status value to main().
>>>>
>>>> *Here are Strachey's (verbatim) own words*
>>>> Suppose T[R] is a Boolean function taking a routine
>>>> (or program) R with no formal or free variables as its
>>>> argument and that for all R, T[R] — True if R terminates
>>>> if run and that T[R] = False if R does not terminate.
>>>> Consider the routine P defined as follows
>>>>
>>>> rec routine P
>>>> §L:if T[P] go to L
>>>> Return §
>>>>
>>>> If T[P] = True the routine P will loop, and it will
>>>> only terminate if T[P] = False. In each case T[P] has
>>>> exactly the wrong value, and this contradiction shows
>>>> that the function T cannot exist.
>>>>
>>>> Strachey is the creator of CPL ancestor to BCPL then B then C
>>>> His code above is written in his CPL programming language.
>>>
>>> I repeat: all Strachey's letter shows is that a decider cannot be
>>> part of that which is being decided.
>>>
>>> /Flibble
>>>
>>
>> Although this <is> one way of putting it, all of the halting problem
>> proofs require that the decider is a part of what is being decided.
>> When we disallow that all of these proofs lose their entire basis and
>> fail to prove anything.
>
> I agree, if these proofs do require a decider to be part of that which
> is being decided then they are indeed invalid for the reason Strachey
> highlights in his letter.
>
> /Flibble
>
I have been saying that they are invalid since 2004, now you are
agreeing with me on this.
comp.theory Peter Olcott Sep 5, 2004, 11:21:57 AM
The Liar Paradox can be shown to be nothing more than
a incorrectly formed statement because of its pathological
self-reference. The Halting Problem can only exist because
of this same sort of pathological self-reference.
https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
Everyone else believes that they are valid and prove that the halting
problem is undecidable.
Strachey does not say that the proofs are invalid he claims that his
simplified version: "shows that the function T cannot exist."
What he everyone else means by function T is a universal halt decider.
Strachey says that his simple example proves that the halting problem is
undecidable.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-07-10 17:34 +0100 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ] |
| Message-ID | <20210710173427.00006b5f@reddwarf.jmc> |
| In reply to | #36058 |
On Sat, 10 Jul 2021 11:08:35 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/10/2021 10:25 AM, Mr Flibble wrote:
> > On Sat, 10 Jul 2021 10:21:26 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/10/2021 10:15 AM, Mr Flibble wrote:
> >>> On Sat, 10 Jul 2021 10:00:51 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/10/2021 9:30 AM, Mr Flibble wrote:
> >>>>> On Sat, 10 Jul 2021 08:54:23 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 7/10/2021 6:40 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 9 Jul 2021 16:13:48 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 7/9/2021 4:08 PM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 9 Jul 2021 14:24:33 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 9 Jul 2021 12:47:12 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>> [Halt Deciding Axiom] When the pure simulation of the
> >>>>>>>>>>>>>> machine description ⟨P⟩ of a machine P on its input I
> >>>>>>>>>>>>>> never halts we know that P(I) never halts.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> No we cannot. In order to remove the pathological
> >>>>>>>>>>>>>> feedback loop such that P does the opposite of whatever
> >>>>>>>>>>>>>> H decides H simply acts as a pure simulator of P thus
> >>>>>>>>>>>>>> having no effect what-so-ever on the behavior of P
> >>>>>>>>>>>>>> until after its halt status decision has been made.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Except your decider can only handle trivial
> >>>>>>>>>>>>> uninteresting cases: if you wish to make progress on
> >>>>>>>>>>>>> this then prove your decider works with a non-trivial
> >>>>>>>>>>>>> case which includes branching logic predicated on
> >>>>>>>>>>>>> arbitrary program input that is unknown a priori to the
> >>>>>>>>>>>>> simulation starting; but before you even do that prove
> >>>>>>>>>>>>> your decider works with a non-trivial case with
> >>>>>>>>>>>>> branching logic predicated on arbitrary program input
> >>>>>>>>>>>>> that *is* known a priori.
> >>>>>>>>>>>>
> >>>>>>>>>>>> You continue to prove to everyone that actually knows
> >>>>>>>>>>>> these things that you are an ignoramus on this subject.
> >>>>>>>>>>>>
> >>>>>>>>>>>> That H correctly decides that all of the standard
> >>>>>>>>>>>> counter-examples templates never halt eliminates the
> >>>>>>>>>>>> entire basis of all of the conventional halting problem
> >>>>>>>>>>>> undecidability proofs.
> >>>>>>>>>>>>> I also note that you repeatedly refuse to address my
> >>>>>>>>>>>>> point regarding how x86 mov instructions can read/write
> >>>>>>>>>>>>> from/to memory mapped I/O rather than RAM so the result
> >>>>>>>>>>>>> of the mov instruction cannot be known a priori. The
> >>>>>>>>>>>>> halting program concerns computing devices and a
> >>>>>>>>>>>>> computing device which cannot do I/O is next to
> >>>>>>>>>>>>> useless, much like your decider (until you actually
> >>>>>>>>>>>>> prove otherwise which I have a feeling is never going
> >>>>>>>>>>>>> to happen as you appear to be stuck in a loop).
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> I continue to note that you repeatedly refuse to address
> >>>>>>>>>>> my point regarding how x86 mov instructions can read/write
> >>>>>>>>>>> from/to memory mapped I/O rather than RAM so the result of
> >>>>>>>>>>> the mov instruction cannot be known a priori. The halting
> >>>>>>>>>>> program concerns computing devices and a computing device
> >>>>>>>>>>> which cannot do I/O is next to useless, much like your
> >>>>>>>>>>> decider (until you actually prove otherwise which I have a
> >>>>>>>>>>> feeling is never going to happen as you appear to be stuck
> >>>>>>>>>>> in a loop).
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> You are the only one that believes that your points have
> >>>>>>>>>> any relevance. That you believe that data movement
> >>>>>>>>>> instructions have anything to do with control flow proves
> >>>>>>>>>> that your points have no relevance.
> >>>>>>>>>
> >>>>>>>>> You literally have no clue about what you are talking about,
> >>>>>>>>> whatsoever. This explains everything.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> *Make sure that you read all of this especially the last
> >>>>>>>> line*
> >>>>>>>>
> >>>>>>>> halt (p, i)
> >>>>>>>> {
> >>>>>>>> if ( program p halts on input i )
> >>>>>>>> return true ; // p halts
> >>>>>>>> else
> >>>>>>>> return false ; // p doesn’t halt
> >>>>>>>> }
> >>>>>>>> Fig. 1. Pseudocode of the Halting Function
> >>>>>>>>
> >>>>>>>> Strachey’s Impossible Program Strachey proposed a program
> >>>>>>>> based on the result of an assumed halting function [2].
> >>>>>>>> The way Strachey’s construction and other similar
> >>>>>>>> constructions are used to show the impossibility of a
> >>>>>>>> decideable halting function is quite similar to Turing’s
> >>>>>>>> original disproof. But the relevant difference we want to
> >>>>>>>> emphasize is that they do not explicitly assume an infinite
> >>>>>>>> number of possible machines (programs) or input data,
> >>>>>>>> because they directly use reductio ad absurdum to prove that
> >>>>>>>> both, Strachey’s construction and the universal halting
> >>>>>>>> function cannot exist.
> >>>>>>>>
> >>>>>>>> strachey ( p )
> >>>>>>>> {
> >>>>>>>> if ( halt (p, p) == true )
> >>>>>>>> L1 : goto L1 ; // loop forever
> >>>>>>>> else
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> Fig. 2. Strachey’s Impossible Program
> >>>>>>>>
> >>>>>>>> The impossibility of Strachey’s construction given in Figure
> >>>>>>>> 2 becomes obvious if one tries to apply the halting function
> >>>>>>>> as follows:
> >>>>>>>>
> >>>>>>>> halt(strachey, strachey)
> >>>>>>>>
> >>>>>>>> Since in this case strachey() itself calls halt(strachey,
> >>>>>>>> strachey), it is required that the direct call of halt() and
> >>>>>>>> the nested call provide the same result. However, this leads
> >>>>>>>> to a contradiction, whatever result halt() returns. Within
> >>>>>>>> this disproof there seems to be no indication why not it
> >>>>>>>> could be even applied to finite-state systems having a
> >>>>>>>> concrete upper bound of state space.
> >>>>>>>>
> >>>>>>>> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
> >>>>>>>>
> >>>>>>>
> >>>>>>> Except your decider can only handle trivial uninteresting
> >>>>>>> cases: if you
> >>>>>>
> >>>>>> Ask other people here if being able to correctly decide the
> >>>>>> strachey case is trivial or uninteresting. Ben might be the
> >>>>>> best one to ask about this.
> >>>>>>
> >>>>>> Here is his original 1965 letter.
> >>>>>> https://academic.oup.com/comjnl/article/7/4/313/354243
> >>>>>
> >>>>> All Strachey's letter shows is that a decider cannot be part of
> >>>>> that which is being decided.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>>
> >>>> // Simplified Linz Ĥ (Linz:1990:319)
> >>>> void P(u32 x)
> >>>> {
> >>>> u32 Input_Halts = H(x, x);
> >>>> if (Input_Halts)
> >>>> HERE: goto HERE;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> u32 Input_Halts = H((u32)P, (u32)P);
> >>>> Output("Input_Halts = ", Input_Halts);
> >>>> }
> >>>>
> >>>> What it shows is that the halting problem proof can be enormously
> >>>> simplified to the impossibility of the H(P,P) in main()
> >>>> returning a correct halt status value to main().
> >>>>
> >>>> *Here are Strachey's (verbatim) own words*
> >>>> Suppose T[R] is a Boolean function taking a routine
> >>>> (or program) R with no formal or free variables as its
> >>>> argument and that for all R, T[R] — True if R terminates
> >>>> if run and that T[R] = False if R does not terminate.
> >>>> Consider the routine P defined as follows
> >>>>
> >>>> rec routine P
> >>>> §L:if T[P] go to L
> >>>> Return §
> >>>>
> >>>> If T[P] = True the routine P will loop, and it will
> >>>> only terminate if T[P] = False. In each case T[P] has
> >>>> exactly the wrong value, and this contradiction shows
> >>>> that the function T cannot exist.
> >>>>
> >>>> Strachey is the creator of CPL ancestor to BCPL then B then C
> >>>> His code above is written in his CPL programming language.
> >>>
> >>> I repeat: all Strachey's letter shows is that a decider cannot be
> >>> part of that which is being decided.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Although this <is> one way of putting it, all of the halting
> >> problem proofs require that the decider is a part of what is being
> >> decided. When we disallow that all of these proofs lose their
> >> entire basis and fail to prove anything.
> >
> > I agree, if these proofs do require a decider to be part of that
> > which is being decided then they are indeed invalid for the reason
> > Strachey highlights in his letter.
> >
> > /Flibble
> >
>
> I have been saying that they are invalid since 2004, now you are
> agreeing with me on this.
>
> comp.theory Peter Olcott Sep 5, 2004, 11:21:57 AM
> The Liar Paradox can be shown to be nothing more than
> a incorrectly formed statement because of its pathological
> self-reference. The Halting Problem can only exist because
> of this same sort of pathological self-reference.
> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>
> Everyone else believes that they are valid and prove that the halting
> problem is undecidable.
They are not valid as [Strachey 1965] falsifies them (if what you say
is correct) HOWEVER given that it doesn't follow that the halting
problem itself is not undecidable just that those particular proofs are
invalid.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-07-10 11:42 -0500 |
| Subject | Re: How do we know that H(P,P)==0 is correct? (V4) [ strachey example ]( You and I ) |
| Message-ID | <H6OdnTryGdZxUHT9nZ2dnUU7-bPNnZ2d@giganews.com> |
| In reply to | #36060 |
On 7/10/2021 11:34 AM, Mr Flibble wrote:
> On Sat, 10 Jul 2021 11:08:35 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/10/2021 10:25 AM, Mr Flibble wrote:
>>> On Sat, 10 Jul 2021 10:21:26 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/10/2021 10:15 AM, Mr Flibble wrote:
>>>>> On Sat, 10 Jul 2021 10:00:51 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 7/10/2021 9:30 AM, Mr Flibble wrote:
>>>>>>> On Sat, 10 Jul 2021 08:54:23 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 7/10/2021 6:40 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 9 Jul 2021 16:13:48 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 7/9/2021 4:08 PM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 9 Jul 2021 14:24:33 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 7/9/2021 2:16 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 9 Jul 2021 12:47:12 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 7/9/2021 12:06 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 9 Jul 2021 08:59:51 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>> [Halt Deciding Axiom] When the pure simulation of the
>>>>>>>>>>>>>>>> machine description ⟨P⟩ of a machine P on its input I
>>>>>>>>>>>>>>>> never halts we know that P(I) never halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No we cannot. In order to remove the pathological
>>>>>>>>>>>>>>>> feedback loop such that P does the opposite of whatever
>>>>>>>>>>>>>>>> H decides H simply acts as a pure simulator of P thus
>>>>>>>>>>>>>>>> having no effect what-so-ever on the behavior of P
>>>>>>>>>>>>>>>> until after its halt status decision has been made.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except your decider can only handle trivial
>>>>>>>>>>>>>>> uninteresting cases: if you wish to make progress on
>>>>>>>>>>>>>>> this then prove your decider works with a non-trivial
>>>>>>>>>>>>>>> case which includes branching logic predicated on
>>>>>>>>>>>>>>> arbitrary program input that is unknown a priori to the
>>>>>>>>>>>>>>> simulation starting; but before you even do that prove
>>>>>>>>>>>>>>> your decider works with a non-trivial case with
>>>>>>>>>>>>>>> branching logic predicated on arbitrary program input
>>>>>>>>>>>>>>> that *is* known a priori.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You continue to prove to everyone that actually knows
>>>>>>>>>>>>>> these things that you are an ignoramus on this subject.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That H correctly decides that all of the standard
>>>>>>>>>>>>>> counter-examples templates never halt eliminates the
>>>>>>>>>>>>>> entire basis of all of the conventional halting problem
>>>>>>>>>>>>>> undecidability proofs.
>>>>>>>>>>>>>>> I also note that you repeatedly refuse to address my
>>>>>>>>>>>>>>> point regarding how x86 mov instructions can read/write
>>>>>>>>>>>>>>> from/to memory mapped I/O rather than RAM so the result
>>>>>>>>>>>>>>> of the mov instruction cannot be known a priori. The
>>>>>>>>>>>>>>> halting program concerns computing devices and a
>>>>>>>>>>>>>>> computing device which cannot do I/O is next to
>>>>>>>>>>>>>>> useless, much like your decider (until you actually
>>>>>>>>>>>>>>> prove otherwise which I have a feeling is never going
>>>>>>>>>>>>>>> to happen as you appear to be stuck in a loop).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I continue to note that you repeatedly refuse to address
>>>>>>>>>>>>> my point regarding how x86 mov instructions can read/write
>>>>>>>>>>>>> from/to memory mapped I/O rather than RAM so the result of
>>>>>>>>>>>>> the mov instruction cannot be known a priori. The halting
>>>>>>>>>>>>> program concerns computing devices and a computing device
>>>>>>>>>>>>> which cannot do I/O is next to useless, much like your
>>>>>>>>>>>>> decider (until you actually prove otherwise which I have a
>>>>>>>>>>>>> feeling is never going to happen as you appear to be stuck
>>>>>>>>>>>>> in a loop).
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are the only one that believes that your points have
>>>>>>>>>>>> any relevance. That you believe that data movement
>>>>>>>>>>>> instructions have anything to do with control flow proves
>>>>>>>>>>>> that your points have no relevance.
>>>>>>>>>>>
>>>>>>>>>>> You literally have no clue about what you are talking about,
>>>>>>>>>>> whatsoever. This explains everything.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *Make sure that you read all of this especially the last
>>>>>>>>>> line*
>>>>>>>>>>
>>>>>>>>>> halt (p, i)
>>>>>>>>>> {
>>>>>>>>>> if ( program p halts on input i )
>>>>>>>>>> return true ; // p halts
>>>>>>>>>> else
>>>>>>>>>> return false ; // p doesn’t halt
>>>>>>>>>> }
>>>>>>>>>> Fig. 1. Pseudocode of the Halting Function
>>>>>>>>>>
>>>>>>>>>> Strachey’s Impossible Program Strachey proposed a program
>>>>>>>>>> based on the result of an assumed halting function [2].
>>>>>>>>>> The way Strachey’s construction and other similar
>>>>>>>>>> constructions are used to show the impossibility of a
>>>>>>>>>> decideable halting function is quite similar to Turing’s
>>>>>>>>>> original disproof. But the relevant difference we want to
>>>>>>>>>> emphasize is that they do not explicitly assume an infinite
>>>>>>>>>> number of possible machines (programs) or input data,
>>>>>>>>>> because they directly use reductio ad absurdum to prove that
>>>>>>>>>> both, Strachey’s construction and the universal halting
>>>>>>>>>> function cannot exist.
>>>>>>>>>>
>>>>>>>>>> strachey ( p )
>>>>>>>>>> {
>>>>>>>>>> if ( halt (p, p) == true )
>>>>>>>>>> L1 : goto L1 ; // loop forever
>>>>>>>>>> else
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Fig. 2. Strachey’s Impossible Program
>>>>>>>>>>
>>>>>>>>>> The impossibility of Strachey’s construction given in Figure
>>>>>>>>>> 2 becomes obvious if one tries to apply the halting function
>>>>>>>>>> as follows:
>>>>>>>>>>
>>>>>>>>>> halt(strachey, strachey)
>>>>>>>>>>
>>>>>>>>>> Since in this case strachey() itself calls halt(strachey,
>>>>>>>>>> strachey), it is required that the direct call of halt() and
>>>>>>>>>> the nested call provide the same result. However, this leads
>>>>>>>>>> to a contradiction, whatever result halt() returns. Within
>>>>>>>>>> this disproof there seems to be no indication why not it
>>>>>>>>>> could be even applied to finite-state systems having a
>>>>>>>>>> concrete upper bound of state space.
>>>>>>>>>>
>>>>>>>>>> https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.206.1468&rep=rep1&type=pdf
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except your decider can only handle trivial uninteresting
>>>>>>>>> cases: if you
>>>>>>>>
>>>>>>>> Ask other people here if being able to correctly decide the
>>>>>>>> strachey case is trivial or uninteresting. Ben might be the
>>>>>>>> best one to ask about this.
>>>>>>>>
>>>>>>>> Here is his original 1965 letter.
>>>>>>>> https://academic.oup.com/comjnl/article/7/4/313/354243
>>>>>>>
>>>>>>> All Strachey's letter shows is that a decider cannot be part of
>>>>>>> that which is being decided.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>>
>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>> void P(u32 x)
>>>>>> {
>>>>>> u32 Input_Halts = H(x, x);
>>>>>> if (Input_Halts)
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> u32 Input_Halts = H((u32)P, (u32)P);
>>>>>> Output("Input_Halts = ", Input_Halts);
>>>>>> }
>>>>>>
>>>>>> What it shows is that the halting problem proof can be enormously
>>>>>> simplified to the impossibility of the H(P,P) in main()
>>>>>> returning a correct halt status value to main().
>>>>>>
>>>>>> *Here are Strachey's (verbatim) own words*
>>>>>> Suppose T[R] is a Boolean function taking a routine
>>>>>> (or program) R with no formal or free variables as its
>>>>>> argument and that for all R, T[R] — True if R terminates
>>>>>> if run and that T[R] = False if R does not terminate.
>>>>>> Consider the routine P defined as follows
>>>>>>
>>>>>> rec routine P
>>>>>> §L:if T[P] go to L
>>>>>> Return §
>>>>>>
>>>>>> If T[P] = True the routine P will loop, and it will
>>>>>> only terminate if T[P] = False. In each case T[P] has
>>>>>> exactly the wrong value, and this contradiction shows
>>>>>> that the function T cannot exist.
>>>>>>
>>>>>> Strachey is the creator of CPL ancestor to BCPL then B then C
>>>>>> His code above is written in his CPL programming language.
>>>>>
>>>>> I repeat: all Strachey's letter shows is that a decider cannot be
>>>>> part of that which is being decided.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Although this <is> one way of putting it, all of the halting
>>>> problem proofs require that the decider is a part of what is being
>>>> decided. When we disallow that all of these proofs lose their
>>>> entire basis and fail to prove anything.
>>>
>>> I agree, if these proofs do require a decider to be part of that
>>> which is being decided then they are indeed invalid for the reason
>>> Strachey highlights in his letter.
>>>
>>> /Flibble
>>>
>>
>> I have been saying that they are invalid since 2004, now you are
>> agreeing with me on this.
>>
>> comp.theory Peter Olcott Sep 5, 2004, 11:21:57 AM
>> The Liar Paradox can be shown to be nothing more than
>> a incorrectly formed statement because of its pathological
>> self-reference. The Halting Problem can only exist because
>> of this same sort of pathological self-reference.
>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>
>> Everyone else believes that they are valid and prove that the halting
>> problem is undecidable.
>
> They are not valid as [Strachey 1965] falsifies them (if what you say
> is correct) HOWEVER given that it doesn't follow that the halting
> problem itself is not undecidable just that those particular proofs are
> invalid.
>
> /Flibble
>
You can check around.
You and I are the only one's here that hold that view.
Ben, Kaz, and Mike would all disagree with you and I on this point.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 5 of 17 — ← Prev page 1 … 3 4 [5] 6 7 … 17 Next page →
Back to top | Article view | comp.theory
csiph-web