Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #38464 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-08-28 11:47 -0500 |
| Last post | 2021-08-28 20:00 -0400 |
| Articles | 20 on this page of 733 — 10 participants |
Back to article view | Back to comp.theory
That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 11:47 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-28 14:52 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 14:12 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-28 16:24 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 15:33 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-28 16:46 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 16:55 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-28 18:29 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 17:38 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 17:38 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-28 19:32 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 18:46 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 18:51 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-28 20:07 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 23:00 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-29 07:00 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-29 08:28 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-29 16:20 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-29 10:30 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-29 17:19 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-29 11:36 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-30 01:00 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-29 20:42 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-31 03:17 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-30 21:35 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-31 04:04 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-30 22:20 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] André G. Isaak <agisaak@gm.invalid> - 2021-08-30 21:35 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-30 23:00 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] André G. Isaak <agisaak@gm.invalid> - 2021-08-30 22:19 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-30 23:31 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] André G. Isaak <agisaak@gm.invalid> - 2021-08-30 22:45 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-31 09:24 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 09:07 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] olcott <NoOne@NoWhere.com> - 2021-08-31 11:08 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] olcott <NoOne@NoWhere.com> - 2021-08-31 11:11 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 10:31 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] olcott <NoOne@NoWhere.com> - 2021-08-31 11:49 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 11:00 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] olcott <NoOne@NoWhere.com> - 2021-08-31 12:55 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 12:40 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] olcott <NoOne@NoWhere.com> - 2021-08-31 14:11 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 14:08 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] olcott <NoOne@NoWhere.com> - 2021-08-31 16:34 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 16:40 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] olcott <NoOne@NoWhere.com> - 2021-08-31 18:29 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 17:39 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] olcott <NoOne@NoWhere.com> - 2021-08-31 19:16 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] Richard Damon <Richard@Damon-Family.org> - 2021-08-31 20:47 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 18:52 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] Richard Damon <Richard@Damon-Family.org> - 2021-08-31 21:23 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-08-31 14:17 -0700
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] olcott <NoOne@NoWhere.com> - 2021-08-31 16:48 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] Richard Damon <Richard@Damon-Family.org> - 2021-08-31 19:26 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] Richard Damon <Richard@Damon-Family.org> - 2021-08-31 21:08 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] Richard Damon <Richard@Damon-Family.org> - 2021-08-31 19:23 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Richard Damon <Richard@Damon-Family.org> - 2021-08-31 06:35 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-31 14:55 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-31 09:28 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Richard Damon <Richard@Damon-Family.org> - 2021-08-31 20:59 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-01 03:28 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-31 21:42 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Richard Damon <news.x.richarddamon@xoxy.net> - 2021-08-31 23:05 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] André G. Isaak <agisaak@gm.invalid> - 2021-08-29 11:22 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] olcott <NoOne@NoWhere.com> - 2021-08-29 12:43 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] André G. Isaak <agisaak@gm.invalid> - 2021-08-29 12:06 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] Richard Damon <Richard@Damon-Family.org> - 2021-08-29 15:42 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-28 18:42 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 22:52 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-28 22:07 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-28 23:13 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-28 22:32 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ dishonesty ? ] olcott <NoOne@NoWhere.com> - 2021-08-28 23:27 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ dishonesty ? ] André G. Isaak <agisaak@gm.invalid> - 2021-08-28 22:34 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ dishonesty ? ] olcott <NoOne@NoWhere.com> - 2021-08-28 23:50 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ dishonesty ? ] Richard Damon <Richard@Damon-Family.org> - 2021-08-29 08:20 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-29 13:53 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-29 13:32 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-29 14:40 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-29 13:48 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-29 14:57 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-29 16:42 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-29 16:16 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-29 18:35 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-29 20:39 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-29 21:52 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-29 19:54 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-29 21:14 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-29 22:35 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-29 20:38 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-29 21:51 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-29 21:00 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-29 22:17 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-29 21:43 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-29 22:54 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-30 06:24 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-30 09:02 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-30 20:13 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-31 03:12 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-30 21:30 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-31 03:53 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-30 22:11 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-31 06:38 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-31 15:04 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-31 09:30 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-31 21:03 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-01 03:45 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-31 22:09 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-31 22:28 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <news.x.richarddamon@xoxy.net> - 2021-09-01 07:51 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 21:47 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-31 23:10 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 22:26 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-08-31 23:32 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-08-31 22:52 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-09-01 08:25 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-09-01 08:54 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-09-01 09:13 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-09-01 19:04 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-01 02:19 -0700
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-09-01 08:27 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-09-01 19:06 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-02 02:40 -0700
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-09-02 09:15 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-02 16:19 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-02 10:34 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-02 22:02 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-02 18:12 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 22:00 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-04 16:46 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 18:41 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-04 17:54 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 19:02 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-04 16:25 -0700
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-04 22:55 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-05 13:02 -0700
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-05 15:13 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 17:36 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Mike <usenet@darjeeling.plus.com> - 2021-09-05 23:37 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <news.x.richarddamon@xoxy.net> - 2021-09-05 20:16 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 09:42 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <news.x.richarddamon@xoxy.net> - 2021-09-06 11:06 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 10:26 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 12:04 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 14:28 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 14:22 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 15:50 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 15:37 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-06 16:59 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 16:58 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-06 18:21 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 17:39 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-06 18:57 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 20:04 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 18:13 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-06 19:46 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 19:07 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-06 20:32 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 20:23 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-06 21:30 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 21:34 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-06 22:42 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 21:49 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-06 22:55 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 22:08 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-06 23:35 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 23:36 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-07 08:51 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-07 08:14 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-07 09:26 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-07 08:18 -0700
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-07 10:34 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 19:04 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] André G. Isaak <agisaak@gm.invalid> - 2021-09-07 09:39 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ][ Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 11:02 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ][ Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-07 10:46 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ][ Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 12:01 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ][ Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-07 12:14 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ][ Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 13:17 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ][ Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-07 13:39 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ][ Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 14:49 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ][ Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-07 15:07 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ][ Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 19:06 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 19:16 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-07 18:46 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 20:49 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 05:59 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-07 09:13 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 19:09 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] olcott <NoOne@NoWhere.com> - 2021-09-07 18:38 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 20:52 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 06:40 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 06:30 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Jeff Barnett <jbb@notatt.com> - 2021-09-06 21:47 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Jeff Barnett <jbb@notatt.com> - 2021-09-06 21:31 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 22:32 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 21:31 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pure functions ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 19:56 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 19:39 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 19:57 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 21:38 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 20:50 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 20:53 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 22:52 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 21:57 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 23:37 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 22:46 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 06:04 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-07 11:10 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 09:00 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-07 16:30 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 10:45 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 19:11 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 18:44 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 20:55 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 01:25 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 19:39 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 21:01 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 03:58 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 19:09 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 18:42 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 21:03 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 22:48 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 21:55 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 23:06 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 22:14 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 23:45 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 22:51 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 06:10 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 09:26 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] olcott <NoOne@NoWhere.com> - 2021-09-06 09:57 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ refuted Rice's theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 11:21 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 00:09 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-04 23:27 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 16:33 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-05 10:52 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 13:03 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 19:48 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-05 14:05 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 23:46 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-06 10:00 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 11:22 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-06 21:24 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-06 16:06 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 19:10 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-06 18:25 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 20:10 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-02 09:10 -0700
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ pathological inputs ] olcott <NoOne@NoWhere.com> - 2021-09-02 11:32 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-02 21:38 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-09-01 06:42 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-01 15:34 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] André G. Isaak <agisaak@gm.invalid> - 2021-09-01 08:45 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-09-01 09:52 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-09-01 19:09 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-09-01 06:38 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-09-01 06:21 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-01 15:44 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-09-01 10:05 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-09-01 19:43 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-02 01:58 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-09-01 20:34 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-02 02:42 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] olcott <NoOne@NoWhere.com> - 2021-09-01 21:18 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-09-01 22:34 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Pathological Input ] olcott <NoOne@NoWhere.com> - 2021-09-01 21:53 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Pathological Input ] André G. Isaak <agisaak@gm.invalid> - 2021-09-01 22:56 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Pathological Input ] olcott <NoOne@NoWhere.com> - 2021-09-02 00:09 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Pathological Input ] André G. Isaak <agisaak@gm.invalid> - 2021-09-01 23:48 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Pathological Input ] olcott <NoOne@NoWhere.com> - 2021-09-02 10:28 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Pathological Input ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 06:17 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-02 12:28 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 10:23 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-02 22:00 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 18:20 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-02 17:46 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 19:01 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-02 18:20 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 19:32 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-02 19:10 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 22:21 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 01:27 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 19:40 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 02:05 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 20:08 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 02:29 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 20:42 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 22:24 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 21:26 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 22:54 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 21:57 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 23:15 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 03:42 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 21:55 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 23:09 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 22:18 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 23:52 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 23:09 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-02 22:59 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 09:05 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 12:49 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 15:11 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 16:58 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 16:23 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 17:31 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 06:32 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-03 04:47 -0700
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 14:41 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 09:20 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 15:58 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 08:51 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-03 08:09 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 09:24 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-03 08:33 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 09:46 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-03 09:12 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 10:28 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-03 09:43 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 15:01 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-03 14:24 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 15:31 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-03 14:58 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 16:18 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 17:43 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-03 15:46 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 17:14 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 18:46 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] André G. Isaak <agisaak@gm.invalid> - 2021-09-03 17:00 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 18:57 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Jeff Barnett <jbb@notatt.com> - 2021-09-03 17:45 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 22:36 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 17:25 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 00:02 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 19:03 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 01:20 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 19:27 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 21:10 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 20:36 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 22:07 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 22:30 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-03 23:12 -0700
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 08:45 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 10:09 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 09:49 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 11:22 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 10:32 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 11:54 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 11:21 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 12:40 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 12:01 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 13:21 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 12:41 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 14:08 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 13:14 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 14:28 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 13:52 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 21:56 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 18:34 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 19:13 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-09-04 02:05 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 20:31 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 20:51 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 15:06 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 22:00 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 17:55 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 20:49 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Mike <usenet@darjeeling.plus.com> - 2021-09-05 03:59 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Andy Walker <anw@cuboid.co.uk> - 2021-09-04 12:58 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Jeff Barnett <jbb@notatt.com> - 2021-09-04 13:59 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 21:26 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-04 16:13 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 22:37 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 16:27 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 15:36 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 17:06 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 11:41 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 14:52 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 16:11 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 09:57 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 11:47 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 11:34 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 10:39 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 11:51 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 09:09 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 12:01 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 15:58 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 10:02 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 16:18 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 12:02 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 21:16 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 03:47 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 21:56 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Jeff Barnett <jbb@notatt.com> - 2021-09-02 22:29 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 15:58 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 10:01 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 16:16 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 10:30 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 16:50 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 14:55 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 16:34 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 15:57 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-03 17:50 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-03 22:40 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-03 17:27 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 01:07 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-03 19:25 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 11:57 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 11:26 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 12:42 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 12:05 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 13:27 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 12:44 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 14:11 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 13:42 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 15:11 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 14:47 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 16:17 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 17:36 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 18:47 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 18:08 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-04 20:14 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 23:02 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 06:40 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 00:34 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 22:58 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 06:44 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 16:22 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-05 10:28 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 17:24 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-05 11:48 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-05 12:16 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 13:21 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-05 12:34 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 14:26 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-05 13:50 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 15:32 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 20:48 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-05 15:25 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 17:45 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-06 00:14 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 10:15 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 09:30 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 11:07 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 10:17 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 14:14 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 14:15 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 15:38 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 15:28 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 16:41 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 16:53 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-09-07 02:55 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 21:07 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 20:17 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 20:13 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 12:25 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 14:20 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 20:23 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-06 20:26 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 14:31 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-06 20:59 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 15:56 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-06 22:03 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 17:07 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 19:20 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-07 01:24 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 19:17 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 18:42 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 17:55 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ end of life on Earth ] olcott <NoOne@NoWhere.com> - 2021-09-06 19:37 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ end of life on Earth ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 19:01 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ end of life on Earth ] olcott <NoOne@NoWhere.com> - 2021-09-06 20:08 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ end of life on Earth ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 21:23 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ end of life on Earth ] André G. Isaak <agisaak@gm.invalid> - 2021-09-06 19:33 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ end of life on Earth ] olcott <NoOne@NoWhere.com> - 2021-09-06 20:45 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ end of life on Earth ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 21:19 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 20:37 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-09-07 16:50 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-07 11:04 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-07 11:09 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] André G. Isaak <agisaak@gm.invalid> - 2021-09-07 10:41 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-07 11:59 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] André G. Isaak <agisaak@gm.invalid> - 2021-09-07 11:55 -0600
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-07 13:15 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-07 23:26 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-07 17:38 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 01:52 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-07 20:12 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-09-08 02:26 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-07 20:45 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 21:52 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-07 21:11 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 22:22 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 11:32 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-06 21:58 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 16:18 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-06 23:55 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 18:32 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-07 01:40 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 19:49 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-07 02:09 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 20:40 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-07 02:57 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 21:17 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 22:56 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 22:05 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 23:51 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-06 22:59 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 06:28 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-07 11:54 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-07 09:07 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-07 16:31 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 10:51 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 01:42 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 20:08 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 21:12 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 20:28 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 21:55 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 21:18 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 22:27 -0400
H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 21:53 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-07 21:09 -0600
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 22:18 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-08 00:14 -0600
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 09:20 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-08 08:48 -0600
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 11:26 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 17:49 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 14:09 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 21:42 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 15:49 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 23:11 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 17:36 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 01:21 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 19:41 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 21:18 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 21:21 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:05 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 22:09 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:31 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 02:54 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 21:07 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 12:02 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 08:59 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 16:32 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 10:46 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 23:29 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 17:50 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 19:23 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-10 03:19 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 21:36 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-10 10:37 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-10 08:43 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-10 21:42 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-10 16:30 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-10 16:10 -0600
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-10 17:38 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-10 17:07 -0600
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-10 18:20 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-10 22:09 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-10 22:03 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-10 22:00 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 21:26 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 21:23 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 20:22 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-08 11:59 -0600
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 13:12 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-08 12:58 -0600
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 14:13 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 14:33 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-08 14:02 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ] olcott <NoOne@NoWhere.com> - 2021-09-08 15:41 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ] André G. Isaak <agisaak@gm.invalid> - 2021-09-08 15:27 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ] olcott <NoOne@NoWhere.com> - 2021-09-08 17:00 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ] André G. Isaak <agisaak@gm.invalid> - 2021-09-08 16:20 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-08 17:34 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-08 19:57 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-08 19:17 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-08 21:23 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-08 21:23 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:12 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-08 19:21 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-08 21:02 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:14 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-08 22:25 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:37 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-08 23:16 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-09 06:58 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-09 09:09 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-09 21:41 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-10 10:00 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-10 09:20 -0700
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-10 11:35 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-10 21:55 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-11 08:57 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-11 16:21 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-11 16:16 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-11 17:35 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-11 17:14 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-11 18:44 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-11 17:53 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-11 19:05 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-11 18:14 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-11 19:41 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-11 22:53 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 06:33 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 08:43 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 09:47 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 12:00 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 11:20 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 12:31 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 11:51 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 13:00 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 12:28 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 13:36 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 12:47 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 13:52 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 13:20 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 15:08 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 14:35 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( SUMMATION ) olcott <NoOne@NoWhere.com> - 2021-09-12 13:44 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( SUMMATION ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 15:14 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( SUMMATION ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 13:18 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( SUMMATION ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 15:24 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 13:57 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 13:01 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 14:12 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 13:16 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 14:26 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 13:34 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 15:00 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 14:30 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 12:37 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 13:51 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 15:17 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-12 13:19 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 13:44 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 12:48 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-12 12:41 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-12 12:18 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-08 23:16 -0600
Re: H1(P,P) is a halt decider ... Andy Walker <anw@cuboid.co.uk> - 2021-09-09 10:21 +0100
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-09 08:34 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-09 15:08 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-09 17:15 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) André G. Isaak <agisaak@gm.invalid> - 2021-09-09 17:18 -0600
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) olcott <NoOne@NoWhere.com> - 2021-09-09 18:31 -0500
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ]( calling your bluff! ) Richard Damon <Richard@Damon-Family.org> - 2021-09-09 21:47 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 19:54 -0400
Re: H1(P,P) is a halt decider for P(P) [ meeting the infinite recursion criteria ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 19:51 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 19:48 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 19:46 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 19:01 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 20:25 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] André G. Isaak <agisaak@gm.invalid> - 2021-09-08 19:09 -0600
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 20:17 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 21:32 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 21:33 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:20 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 22:30 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:50 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 23:10 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 07:05 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 09:16 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 16:05 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 10:25 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 16:41 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 10:51 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 23:29 +0100
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 19:30 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 18:50 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 20:38 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 19:46 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 22:25 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 22:19 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 22:05 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 20:17 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 07:15 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 07:04 -0400
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 09:39 -0500
Re: H1(P,P) is a halt decider for P(P) [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 20:01 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-07 22:33 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 03:55 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-07 22:07 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 07:09 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 15:58 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 14:08 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 21:42 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 15:53 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-08 23:52 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 18:10 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 20:11 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 01:21 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 19:37 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 21:30 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 21:25 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:25 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 02:54 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 21:14 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:29 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 22:39 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-08 23:48 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-08 23:08 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 07:09 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 09:18 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 20:53 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 12:02 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 08:47 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 16:18 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 10:31 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-09 23:29 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 21:14 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] olcott <NoOne@NoWhere.com> - 2021-09-09 20:29 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] Richard Damon <Richard@Damon-Family.org> - 2021-09-09 21:02 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-06 20:54 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <news.x.richarddamon@xoxy.net> - 2021-09-05 12:34 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-04 22:22 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 16:42 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 00:09 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-04 23:25 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 06:58 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 17:12 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] olcott <NoOne@NoWhere.com> - 2021-09-05 11:40 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Richard Damon <Richard@Damon-Family.org> - 2021-09-05 12:51 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-05 20:38 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 22:49 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 22:35 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 21:50 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 23:04 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] olcott <NoOne@NoWhere.com> - 2021-09-02 22:17 -0500
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] Richard Damon <Richard@Damon-Family.org> - 2021-09-02 23:53 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-08-30 00:54 +0100
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-29 15:45 -0400
Re: That P(P) of main() halts does not contradict H(P,P)==0 [ exception to the rule ] Richard Damon <Richard@Damon-Family.org> - 2021-08-28 20:00 -0400
Page 5 of 37 — ← Prev page 1 … 3 4 [5] 6 7 … 37 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-29 14:57 -0500 |
| Message-ID | <wKSdnbl3gdRee7b8nZ2dnUU7-cnNnZ2d@giganews.com> |
| In reply to | #38525 |
On 8/29/2021 2:48 PM, André G. Isaak wrote:
> On 2021-08-29 13:40, olcott wrote:
>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>> On 2021-08-29 12:53, olcott wrote:
>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>
>>>>>> I will take this to mean that you already know that
>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>
>>>>> Purely for sake of argument, lets imagine that your position
>>>>> actually makes sense (it does not, but we are imaging).
>>>>>
>>>>> You are trying to claim that P(P) represents a different
>>>>> computation when it is run independently than when it is run as an
>>>>> input to your H.
>>>>>
>>>>> Lets call those hypothetical two computations P(P)_independent and
>>>>> P(P)_input.
>>>>>
>>>>
>>>> This is already fully addressed by line 1 and line 3 of main().
>>>> If you want to come up with different naming conventions so that you
>>>> don't have to bother understanding what I said I will not oblige.
>>>
>>>> int main()
>>>> {
>>>> P(P);
>>>> H1(P,P);
>>>> H(P,P);
>>>> }
>>>>
>>>> H1 has identical code to H.
>>>>
>>>>
>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>> P(P)_independent? A universal halt decider, after all, needs to be
>>>>> able to evalute *all* computations.
>>>
>>> So what's the answer to the actual question? How do I ask your Halt
>>> decider about the behaviour P(P)_independent?
>>>
>>
>> You don't because it does not know English, you translate your
>> question to be about line 1,2,3 of main() and then go look up what I
>> already said.
>
> If I want H to tell me whether P(P)_independent halts, then WHAT THE
> FUCK ARGUMENT do I pass to H? This is not a difficult question.
>
I have no idea what you are talking about unless you are talking about
the first line of main() above.
> According to you, H(P, P) reports on the behaviour of P(P)_Input.
>
> How do I get it to report on the behaviour of P(P)_independent?
>
> If they're distinct computations, H needs to be able to answer about
> either of them.
>
> André
>
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-29 16:42 -0400 |
| Message-ID | <mjSWI.6394$dI3.5836@fx10.iad> |
| In reply to | #38526 |
On 8/29/21 3:57 PM, olcott wrote:
> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>> On 2021-08-29 13:40, olcott wrote:
>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>> On 2021-08-29 12:53, olcott wrote:
>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>
>>>>>>> I will take this to mean that you already know that
>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>
>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>
>>>>>> You are trying to claim that P(P) represents a different
>>>>>> computation when it is run independently than when it is run as an
>>>>>> input to your H.
>>>>>>
>>>>>> Lets call those hypothetical two computations P(P)_independent and
>>>>>> P(P)_input.
>>>>>>
>>>>>
>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>> If you want to come up with different naming conventions so that
>>>>> you don't have to bother understanding what I said I will not oblige.
>>>>
>>>>> int main()
>>>>> {
>>>>> P(P);
>>>>> H1(P,P);
>>>>> H(P,P);
>>>>> }
>>>>>
>>>>> H1 has identical code to H.
>>>>>
>>>>>
>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>> P(P)_independent? A universal halt decider, after all, needs to be
>>>>>> able to evalute *all* computations.
>>>>
>>>> So what's the answer to the actual question? How do I ask your Halt
>>>> decider about the behaviour P(P)_independent?
>>>>
>>>
>>> You don't because it does not know English, you translate your
>>> question to be about line 1,2,3 of main() and then go look up what I
>>> already said.
>>
>> If I want H to tell me whether P(P)_independent halts, then WHAT THE
>> FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>
>
> I have no idea what you are talking about unless you are talking about
> the first line of main() above.
I.E., you can't ask H to decide the REAL P(P) computation, so it fails
to be the decider of Linz.
Probably because H isn't itself a computation, so neither is H^ (aka P),
and its behavior is different depending on how it is used.
Since H isn't a computation, it isn't the equivalent of a Turing
Machine, so it doesn't apply to Theories based on that, like Deciders.
>
>> According to you, H(P, P) reports on the behaviour of P(P)_Input.
>>
>> How do I get it to report on the behaviour of P(P)_independent?
>>
>> If they're distinct computations, H needs to be able to answer about
>> either of them.
>>
>> André
>>
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-08-29 16:16 -0600 |
| Message-ID | <sgh10b$veo$1@dont-email.me> |
| In reply to | #38526 |
On 2021-08-29 13:57, olcott wrote:
> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>> On 2021-08-29 13:40, olcott wrote:
>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>> On 2021-08-29 12:53, olcott wrote:
>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>
>>>>>>> I will take this to mean that you already know that
>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>
>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>
>>>>>> You are trying to claim that P(P) represents a different
>>>>>> computation when it is run independently than when it is run as an
>>>>>> input to your H.
>>>>>>
>>>>>> Lets call those hypothetical two computations P(P)_independent and
>>>>>> P(P)_input.
>>>>>>
>>>>>
>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>> If you want to come up with different naming conventions so that
>>>>> you don't have to bother understanding what I said I will not oblige.
>>>>
>>>>> int main()
>>>>> {
>>>>> P(P);
>>>>> H1(P,P);
>>>>> H(P,P);
>>>>> }
>>>>>
>>>>> H1 has identical code to H.
>>>>>
>>>>>
>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>> P(P)_independent? A universal halt decider, after all, needs to be
>>>>>> able to evalute *all* computations.
>>>>
>>>> So what's the answer to the actual question? How do I ask your Halt
>>>> decider about the behaviour P(P)_independent?
>>>>
>>>
>>> You don't because it does not know English, you translate your
>>> question to be about line 1,2,3 of main() and then go look up what I
>>> already said.
>>
>> If I want H to tell me whether P(P)_independent halts, then WHAT THE
>> FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>
>
> I have no idea what you are talking about unless you are talking about
> the first line of main() above.
Yes, I am talking about the first line of main. How do I ask H about the
behaviour of *that* computation. The one that halts and which
corresponds to the Linz counterexample which you claim is the only case
you need to get right. What argument does one give to H if one wants H
to tell us that that computation halts?
André
>> According to you, H(P, P) reports on the behaviour of P(P)_Input.
>>
>> How do I get it to report on the behaviour of P(P)_independent?
>>
>> If they're distinct computations, H needs to be able to answer about
>> either of them.
>>
>> André
>>
>>
>
>
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-29 18:35 -0400 |
| Message-ID | <5ZTWI.5648$%Z2.2758@fx06.iad> |
| In reply to | #38529 |
On 8/29/21 6:16 PM, André G. Isaak wrote:
> On 2021-08-29 13:57, olcott wrote:
>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>> On 2021-08-29 13:40, olcott wrote:
>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>
>>>>>>>> I will take this to mean that you already know that
>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>
>>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>>
>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>> computation when it is run independently than when it is run as
>>>>>>> an input to your H.
>>>>>>>
>>>>>>> Lets call those hypothetical two computations P(P)_independent
>>>>>>> and P(P)_input.
>>>>>>>
>>>>>>
>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>> If you want to come up with different naming conventions so that
>>>>>> you don't have to bother understanding what I said I will not oblige.
>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> P(P);
>>>>>> H1(P,P);
>>>>>> H(P,P);
>>>>>> }
>>>>>>
>>>>>> H1 has identical code to H.
>>>>>>
>>>>>>
>>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>>> P(P)_independent? A universal halt decider, after all, needs to
>>>>>>> be able to evalute *all* computations.
>>>>>
>>>>> So what's the answer to the actual question? How do I ask your Halt
>>>>> decider about the behaviour P(P)_independent?
>>>>>
>>>>
>>>> You don't because it does not know English, you translate your
>>>> question to be about line 1,2,3 of main() and then go look up what I
>>>> already said.
>>>
>>> If I want H to tell me whether P(P)_independent halts, then WHAT THE
>>> FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>>
>>
>> I have no idea what you are talking about unless you are talking about
>> the first line of main() above.
>
> Yes, I am talking about the first line of main. How do I ask H about the
> behaviour of *that* computation. The one that halts and which
> corresponds to the Linz counterexample which you claim is the only case
> you need to get right. What argument does one give to H if one wants H
> to tell us that that computation halts?
>
> André
From my understanding of what PO is saying, and he can correct me if I
am wrong, the issue is that H doesn't take 'A Computation', but a
'Program/Input'. When we ask about P(P), we run into the issue that P
calls H, and the operation of H is dependent on it execution
environment. Simulated version of H seem to never abort their
simulations, so the simulated P is non-halting since it calls an H that
doesn't abort its simulation, while the P run at the top level gets the
same answer from H as H run as a top level program, Ps simulated by a
simulating Halt Decider of the same 'type' never get an answer.
Basically, this means that H isn't a Computation by the classical
Compuation Theory Definition, and thus neither is P (aka H^) so getting
different answers for different cases is allowed.
Of course, this also means that he is talking about POOP, not Halting
Theory, but he can't seem to tell the difference.
>
>>> According to you, H(P, P) reports on the behaviour of P(P)_Input.
>>>
>>> How do I get it to report on the behaviour of P(P)_independent?
>>>
>>> If they're distinct computations, H needs to be able to answer about
>>> either of them.
>>>
>>> André
>>>
>>>
>>
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-29 20:39 -0500 |
| Message-ID | <bdadnXqOf5JAq7H8nZ2dnUU7-NnNnZ2d@giganews.com> |
| In reply to | #38529 |
On 8/29/2021 5:16 PM, André G. Isaak wrote:
> On 2021-08-29 13:57, olcott wrote:
>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>> On 2021-08-29 13:40, olcott wrote:
>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>
>>>>>>>> I will take this to mean that you already know that
>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>
>>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>>
>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>> computation when it is run independently than when it is run as
>>>>>>> an input to your H.
>>>>>>>
>>>>>>> Lets call those hypothetical two computations P(P)_independent
>>>>>>> and P(P)_input.
>>>>>>>
>>>>>>
>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>> If you want to come up with different naming conventions so that
>>>>>> you don't have to bother understanding what I said I will not oblige.
>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> P(P);
>>>>>> H1(P,P);
>>>>>> H(P,P);
>>>>>> }
>>>>>>
>>>>>> H1 has identical code to H.
>>>>>>
>>>>>>
>>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>>> P(P)_independent? A universal halt decider, after all, needs to
>>>>>>> be able to evalute *all* computations.
>>>>>
>>>>> So what's the answer to the actual question? How do I ask your Halt
>>>>> decider about the behaviour P(P)_independent?
>>>>>
>>>>
>>>> You don't because it does not know English, you translate your
>>>> question to be about line 1,2,3 of main() and then go look up what I
>>>> already said.
>>>
>>> If I want H to tell me whether P(P)_independent halts, then WHAT THE
>>> FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>>
>>
>> I have no idea what you are talking about unless you are talking about
>> the first line of main() above.
>
> Yes, I am talking about the first line of main. How do I ask H about the
> behaviour of *that* computation. The one that halts and which
> corresponds to the Linz counterexample which you claim is the only case
> you need to get right. What argument does one give to H if one wants H
> to tell us that that computation halts?
Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
Ĥ applied to ⟨Ĥ1⟩
corresponds to P(P) of main().
Ĥ.qx applied to ⟨Ĥ1⟩ ⟨Ĥ2⟩
corresponds to the H(P,P) called from the P(P) of main().
P(P) of main() corresponds to H1(P,P) of main().
P(P) of main() halts and H1(P,P) says its input halts.
>
> André
>
>>> According to you, H(P, P) reports on the behaviour of P(P)_Input.
>>>
>>> How do I get it to report on the behaviour of P(P)_independent?
>>>
>>> If they're distinct computations, H needs to be able to answer about
>>> either of them.
>>>
>>> André
>>>
>>>
>>
>>
>
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-29 21:52 -0400 |
| Message-ID | <URWWI.5048$Dr.3248@fx40.iad> |
| In reply to | #38533 |
On 8/29/21 9:39 PM, olcott wrote:
> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>> On 2021-08-29 13:57, olcott wrote:
>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>> On 2021-08-29 13:40, olcott wrote:
>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>
>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>
>>>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>>>
>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>> computation when it is run independently than when it is run as
>>>>>>>> an input to your H.
>>>>>>>>
>>>>>>>> Lets call those hypothetical two computations P(P)_independent
>>>>>>>> and P(P)_input.
>>>>>>>>
>>>>>>>
>>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>>> If you want to come up with different naming conventions so that
>>>>>>> you don't have to bother understanding what I said I will not
>>>>>>> oblige.
>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> P(P);
>>>>>>> H1(P,P);
>>>>>>> H(P,P);
>>>>>>> }
>>>>>>>
>>>>>>> H1 has identical code to H.
>>>>>>>
>>>>>>>
>>>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>>>> P(P)_independent? A universal halt decider, after all, needs to
>>>>>>>> be able to evalute *all* computations.
>>>>>>
>>>>>> So what's the answer to the actual question? How do I ask your
>>>>>> Halt decider about the behaviour P(P)_independent?
>>>>>>
>>>>>
>>>>> You don't because it does not know English, you translate your
>>>>> question to be about line 1,2,3 of main() and then go look up what
>>>>> I already said.
>>>>
>>>> If I want H to tell me whether P(P)_independent halts, then WHAT THE
>>>> FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>>>
>>>
>>> I have no idea what you are talking about unless you are talking
>>> about the first line of main() above.
>>
>> Yes, I am talking about the first line of main. How do I ask H about
>> the behaviour of *that* computation. The one that halts and which
>> corresponds to the Linz counterexample which you claim is the only
>> case you need to get right. What argument does one give to H if one
>> wants H to tell us that that computation halts?
>
>
> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>
>
>
> Ĥ applied to ⟨Ĥ1⟩
> corresponds to P(P) of main().
>
> Ĥ.qx applied to ⟨Ĥ1⟩ ⟨Ĥ2⟩
> corresponds to the H(P,P) called from the P(P) of main().
>
>
>
>
> P(P) of main() corresponds to H1(P,P) of main().
> P(P) of main() halts and H1(P,P) says its input halts.
Which doesn't answer how we ask H to predict that ACTUAL machine P(P) as
run from main.
You answer is basically you can't, so you are in effect saying that H
fails to be able to be asked the one question that it was designed to
answer, because it interprets that question as asking about a different
machine.
Only its 'brother' H1 can do that, but the H1 can't answer for its H1^
machine, which it would need to do, since you need to make H and H1
different computations or they fail to give the same answer when asked
the same question even in the same context.
>
>>
>> André
>>
>>>> According to you, H(P, P) reports on the behaviour of P(P)_Input.
>>>>
>>>> How do I get it to report on the behaviour of P(P)_independent?
>>>>
>>>> If they're distinct computations, H needs to be able to answer about
>>>> either of them.
>>>>
>>>> André
>>>>
>>>>
>>>
>>>
>>
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-08-29 19:54 -0600 |
| Message-ID | <sghdok$1sp$1@dont-email.me> |
| In reply to | #38533 |
On 2021-08-29 19:39, olcott wrote:
> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>> On 2021-08-29 13:57, olcott wrote:
>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>> On 2021-08-29 13:40, olcott wrote:
>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>
>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>
>>>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>>>
>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>> computation when it is run independently than when it is run as
>>>>>>>> an input to your H.
>>>>>>>>
>>>>>>>> Lets call those hypothetical two computations P(P)_independent
>>>>>>>> and P(P)_input.
>>>>>>>>
>>>>>>>
>>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>>> If you want to come up with different naming conventions so that
>>>>>>> you don't have to bother understanding what I said I will not
>>>>>>> oblige.
>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> P(P);
>>>>>>> H1(P,P);
>>>>>>> H(P,P);
>>>>>>> }
>>>>>>>
>>>>>>> H1 has identical code to H.
>>>>>>>
>>>>>>>
>>>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>>>> P(P)_independent? A universal halt decider, after all, needs to
>>>>>>>> be able to evalute *all* computations.
>>>>>>
>>>>>> So what's the answer to the actual question? How do I ask your
>>>>>> Halt decider about the behaviour P(P)_independent?
>>>>>>
>>>>>
>>>>> You don't because it does not know English, you translate your
>>>>> question to be about line 1,2,3 of main() and then go look up what
>>>>> I already said.
>>>>
>>>> If I want H to tell me whether P(P)_independent halts, then WHAT THE
>>>> FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>>>
>>>
>>> I have no idea what you are talking about unless you are talking
>>> about the first line of main() above.
>>
>> Yes, I am talking about the first line of main. How do I ask H about
>> the behaviour of *that* computation. The one that halts and which
>> corresponds to the Linz counterexample which you claim is the only
>> case you need to get right. What argument does one give to H if one
>> wants H to tell us that that computation halts?
>
>
> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
I'm asking about C functions. The above has nothing to do with C functions.
I am asking what *argument* you would pass to H in order to get it to
report on the halting behaviour of P(P) in main.
It's a really simply question. I have no idea why you don't simply
answer it.
H(__, __) <- fill in the blanks
>
>
> Ĥ applied to ⟨Ĥ1⟩
> corresponds to P(P) of main().
>
> Ĥ.qx applied to ⟨Ĥ1⟩ ⟨Ĥ2⟩
> corresponds to the H(P,P) called from the P(P) of main().
>
>
>
>
> P(P) of main() corresponds to H1(P,P) of main().
> P(P) of main() halts and H1(P,P) says its input halts.
Earlier you claimed that H and H1 had identical code. How, then, can
H1(P, P) give a different answer from H(P, P)?
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-29 21:14 -0500 |
| Message-ID | <DKWdnZYCuoB2o7H8nZ2dnUU78b_NnZ2d@giganews.com> |
| In reply to | #38536 |
On 8/29/2021 8:54 PM, André G. Isaak wrote:
> On 2021-08-29 19:39, olcott wrote:
>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>> On 2021-08-29 13:57, olcott wrote:
>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>
>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>
>>>>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>>>>
>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>> computation when it is run independently than when it is run as
>>>>>>>>> an input to your H.
>>>>>>>>>
>>>>>>>>> Lets call those hypothetical two computations P(P)_independent
>>>>>>>>> and P(P)_input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>>>> If you want to come up with different naming conventions so that
>>>>>>>> you don't have to bother understanding what I said I will not
>>>>>>>> oblige.
>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> P(P);
>>>>>>>> H1(P,P);
>>>>>>>> H(P,P);
>>>>>>>> }
>>>>>>>>
>>>>>>>> H1 has identical code to H.
>>>>>>>>
>>>>>>>>
>>>>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>>>>> P(P)_independent? A universal halt decider, after all, needs to
>>>>>>>>> be able to evalute *all* computations.
>>>>>>>
>>>>>>> So what's the answer to the actual question? How do I ask your
>>>>>>> Halt decider about the behaviour P(P)_independent?
>>>>>>>
>>>>>>
>>>>>> You don't because it does not know English, you translate your
>>>>>> question to be about line 1,2,3 of main() and then go look up what
>>>>>> I already said.
>>>>>
>>>>> If I want H to tell me whether P(P)_independent halts, then WHAT
>>>>> THE FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>>>>
>>>>
>>>> I have no idea what you are talking about unless you are talking
>>>> about the first line of main() above.
>>>
>>> Yes, I am talking about the first line of main. How do I ask H about
>>> the behaviour of *that* computation. The one that halts and which
>>> corresponds to the Linz counterexample which you claim is the only
>>> case you need to get right. What argument does one give to H if one
>>> wants H to tell us that that computation halts?
>>
>>
>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>
> I'm asking about C functions. The above has nothing to do with C functions.
>
You asked about the Linz counter example that <is> the Linz counter
example.
>
> I am asking what *argument* you would pass to H in order to get it to
> report on the halting behaviour of P(P) in main.
>
You might as well have asked:
How do you convert your pet cat into a 20 story office building?
H(P,P) from main and P(P) from main() are fundamentally different
computations there is no conversion.
To get similar behavior to P(P) of main() you execute H1(P,P) of main().
> It's a really simply question. I have no idea why you don't simply
> answer it.
>
> H(__, __) <- fill in the blanks
>
>>
>>
>> Ĥ applied to ⟨Ĥ1⟩
>> corresponds to P(P) of main().
>>
>> Ĥ.qx applied to ⟨Ĥ1⟩ ⟨Ĥ2⟩
>> corresponds to the H(P,P) called from the P(P) of main().
>>
>>
>>
>>
>> P(P) of main() corresponds to H1(P,P) of main().
>> P(P) of main() halts and H1(P,P) says its input halts.
>
> Earlier you claimed that H and H1 had identical code. How, then, can
> H1(P, P) give a different answer from H(P, P)?
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-29 22:35 -0400 |
| Message-ID | <%tXWI.1236$2B4.1077@fx04.iad> |
| In reply to | #38537 |
On 8/29/21 10:14 PM, olcott wrote:
> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>> On 2021-08-29 19:39, olcott wrote:
>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>> On 2021-08-29 13:57, olcott wrote:
>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>
>>>>>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>>>>>
>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>> computation when it is run independently than when it is run
>>>>>>>>>> as an input to your H.
>>>>>>>>>>
>>>>>>>>>> Lets call those hypothetical two computations P(P)_independent
>>>>>>>>>> and P(P)_input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>>>>> If you want to come up with different naming conventions so
>>>>>>>>> that you don't have to bother understanding what I said I will
>>>>>>>>> not oblige.
>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> P(P);
>>>>>>>>> H1(P,P);
>>>>>>>>> H(P,P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> H1 has identical code to H.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>>>>>> P(P)_independent? A universal halt decider, after all, needs
>>>>>>>>>> to be able to evalute *all* computations.
>>>>>>>>
>>>>>>>> So what's the answer to the actual question? How do I ask your
>>>>>>>> Halt decider about the behaviour P(P)_independent?
>>>>>>>>
>>>>>>>
>>>>>>> You don't because it does not know English, you translate your
>>>>>>> question to be about line 1,2,3 of main() and then go look up
>>>>>>> what I already said.
>>>>>>
>>>>>> If I want H to tell me whether P(P)_independent halts, then WHAT
>>>>>> THE FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>>>>>
>>>>>
>>>>> I have no idea what you are talking about unless you are talking
>>>>> about the first line of main() above.
>>>>
>>>> Yes, I am talking about the first line of main. How do I ask H about
>>>> the behaviour of *that* computation. The one that halts and which
>>>> corresponds to the Linz counterexample which you claim is the only
>>>> case you need to get right. What argument does one give to H if one
>>>> wants H to tell us that that computation halts?
>>>
>>>
>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>
>> I'm asking about C functions. The above has nothing to do with C
>> functions.
>>
>
> You asked about the Linz counter example that <is> the Linz counter
> example.
>
>>
>> I am asking what *argument* you would pass to H in order to get it to
>> report on the halting behaviour of P(P) in main.
>>
>
> You might as well have asked:
> How do you convert your pet cat into a 20 story office building?
>
> H(P,P) from main and P(P) from main() are fundamentally different
> computations there is no conversion.
>
> To get similar behavior to P(P) of main() you execute H1(P,P) of main().
So H fails to do what it is supposed to do?
Remember to purpose of a Halt Decider is to tell you if the machine that
the input represents halts.
If there is no way to actual provide an input to H to ask it what the
machine P(P) (or from the proof H^(H^) ) would do, is H really a Halt
Decider?
You have dug yourself so deep into the hole that you seem to have
forgotten what the initial problem actually was.
>
>> It's a really simply question. I have no idea why you don't simply
>> answer it.
>>
>
>
>
>> H(__, __) <- fill in the blanks
>>
>>>
>>>
>>> Ĥ applied to ⟨Ĥ1⟩
>>> corresponds to P(P) of main().
>>>
>>> Ĥ.qx applied to ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>> corresponds to the H(P,P) called from the P(P) of main().
>>>
>>>
>>>
>>>
>>> P(P) of main() corresponds to H1(P,P) of main().
>>> P(P) of main() halts and H1(P,P) says its input halts.
>>
>> Earlier you claimed that H and H1 had identical code. How, then, can
>> H1(P, P) give a different answer from H(P, P)?
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-08-29 20:38 -0600 |
| Message-ID | <sghgbn$f4r$1@dont-email.me> |
| In reply to | #38537 |
On 2021-08-29 20:14, olcott wrote:
> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>> On 2021-08-29 19:39, olcott wrote:
>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>> On 2021-08-29 13:57, olcott wrote:
>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>
>>>>>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>>>>>
>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>> computation when it is run independently than when it is run
>>>>>>>>>> as an input to your H.
>>>>>>>>>>
>>>>>>>>>> Lets call those hypothetical two computations P(P)_independent
>>>>>>>>>> and P(P)_input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>>>>> If you want to come up with different naming conventions so
>>>>>>>>> that you don't have to bother understanding what I said I will
>>>>>>>>> not oblige.
>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> P(P);
>>>>>>>>> H1(P,P);
>>>>>>>>> H(P,P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> H1 has identical code to H.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>>>>>> P(P)_independent? A universal halt decider, after all, needs
>>>>>>>>>> to be able to evalute *all* computations.
>>>>>>>>
>>>>>>>> So what's the answer to the actual question? How do I ask your
>>>>>>>> Halt decider about the behaviour P(P)_independent?
>>>>>>>>
>>>>>>>
>>>>>>> You don't because it does not know English, you translate your
>>>>>>> question to be about line 1,2,3 of main() and then go look up
>>>>>>> what I already said.
>>>>>>
>>>>>> If I want H to tell me whether P(P)_independent halts, then WHAT
>>>>>> THE FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>>>>>
>>>>>
>>>>> I have no idea what you are talking about unless you are talking
>>>>> about the first line of main() above.
>>>>
>>>> Yes, I am talking about the first line of main. How do I ask H about
>>>> the behaviour of *that* computation. The one that halts and which
>>>> corresponds to the Linz counterexample which you claim is the only
>>>> case you need to get right. What argument does one give to H if one
>>>> wants H to tell us that that computation halts?
>>>
>>>
>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>
>> I'm asking about C functions. The above has nothing to do with C
>> functions.
>>
>
> You asked about the Linz counter example that <is> the Linz counter
> example.
>
>>
>> I am asking what *argument* you would pass to H in order to get it to
>> report on the halting behaviour of P(P) in main.
>>
>
> You might as well have asked:
> How do you convert your pet cat into a 20 story office building?
>
> H(P,P) from main and P(P) from main() are fundamentally different
> computations there is no conversion.
Who said anything about 'conversion'? I'm asking what *argument* you
would pass to H to get it to answer about P(P). The one in main.
A halt decider is supposed to be able to determine whether *any*
computation halts.
The P(P) in main is supposedly a computation, so there *must* be a way
of asking your H about it.
> To get similar behavior to P(P) of main() you execute H1(P,P) of main().
Again, you claimed that H and H1 have identical code, so how can they
behave differently when given the same input?
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-29 21:51 -0500 |
| Message-ID | <gd6dnaRLzq4q2rH8nZ2dnUU7-WHNnZ2d@giganews.com> |
| In reply to | #38539 |
On 8/29/2021 9:38 PM, André G. Isaak wrote:
> On 2021-08-29 20:14, olcott wrote:
>> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>>> On 2021-08-29 19:39, olcott wrote:
>>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>>> On 2021-08-29 13:57, olcott wrote:
>>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>>
>>>>>>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>>>>>>
>>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>>> computation when it is run independently than when it is run
>>>>>>>>>>> as an input to your H.
>>>>>>>>>>>
>>>>>>>>>>> Lets call those hypothetical two computations
>>>>>>>>>>> P(P)_independent and P(P)_input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>>>>>> If you want to come up with different naming conventions so
>>>>>>>>>> that you don't have to bother understanding what I said I will
>>>>>>>>>> not oblige.
>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> P(P);
>>>>>>>>>> H1(P,P);
>>>>>>>>>> H(P,P);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> H1 has identical code to H.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> So how exactly do I ask your Halt decider about the behaviour
>>>>>>>>>>> P(P)_independent? A universal halt decider, after all, needs
>>>>>>>>>>> to be able to evalute *all* computations.
>>>>>>>>>
>>>>>>>>> So what's the answer to the actual question? How do I ask your
>>>>>>>>> Halt decider about the behaviour P(P)_independent?
>>>>>>>>>
>>>>>>>>
>>>>>>>> You don't because it does not know English, you translate your
>>>>>>>> question to be about line 1,2,3 of main() and then go look up
>>>>>>>> what I already said.
>>>>>>>
>>>>>>> If I want H to tell me whether P(P)_independent halts, then WHAT
>>>>>>> THE FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>>>>>>
>>>>>>
>>>>>> I have no idea what you are talking about unless you are talking
>>>>>> about the first line of main() above.
>>>>>
>>>>> Yes, I am talking about the first line of main. How do I ask H
>>>>> about the behaviour of *that* computation. The one that halts and
>>>>> which corresponds to the Linz counterexample which you claim is the
>>>>> only case you need to get right. What argument does one give to H
>>>>> if one wants H to tell us that that computation halts?
>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>
>>> I'm asking about C functions. The above has nothing to do with C
>>> functions.
>>>
>>
>> You asked about the Linz counter example that <is> the Linz counter
>> example.
>>
>>>
>>> I am asking what *argument* you would pass to H in order to get it to
>>> report on the halting behaviour of P(P) in main.
>>>
>>
>> You might as well have asked:
>> How do you convert your pet cat into a 20 story office building?
>>
>> H(P,P) from main and P(P) from main() are fundamentally different
>> computations there is no conversion.
>
> Who said anything about 'conversion'? I'm asking what *argument* you
> would pass to H to get it to answer about P(P). The one in main.
>
It is utterly impossible.
> A halt decider is supposed to be able to determine whether *any*
> computation halts.
>
The only two equivalent computations are line 1 of main and line 2 of
main. Line one of main halts. Line 2 of main() reports that its input
halts.
Line 3 of main is a fundamentally different computation than line 1 or
line 2. There is nothing in the universe that can be done to make line 3
behave line 1 or line 2 besides replacing it with line 1 or line 2.
> The P(P) in main is supposedly a computation, so there *must* be a way
> of asking your H about it.
>
>> To get similar behavior to P(P) of main() you execute H1(P,P) of main().
>
> Again, you claimed that H and H1 have identical code, so how can they
> behave differently when given the same input?
>
> André
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-08-29 21:00 -0600 |
| Message-ID | <sghhk2$kfr$1@dont-email.me> |
| In reply to | #38540 |
On 2021-08-29 20:51, olcott wrote:
> On 8/29/2021 9:38 PM, André G. Isaak wrote:
>> On 2021-08-29 20:14, olcott wrote:
>>> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>>>> On 2021-08-29 19:39, olcott wrote:
>>>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>>>> On 2021-08-29 13:57, olcott wrote:
>>>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>>>
>>>>>>>>>>>> Purely for sake of argument, lets imagine that your position
>>>>>>>>>>>> actually makes sense (it does not, but we are imaging).
>>>>>>>>>>>>
>>>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>>>> computation when it is run independently than when it is run
>>>>>>>>>>>> as an input to your H.
>>>>>>>>>>>>
>>>>>>>>>>>> Lets call those hypothetical two computations
>>>>>>>>>>>> P(P)_independent and P(P)_input.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>>>>>>> If you want to come up with different naming conventions so
>>>>>>>>>>> that you don't have to bother understanding what I said I
>>>>>>>>>>> will not oblige.
>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> P(P);
>>>>>>>>>>> H1(P,P);
>>>>>>>>>>> H(P,P);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> H1 has identical code to H.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> So how exactly do I ask your Halt decider about the
>>>>>>>>>>>> behaviour P(P)_independent? A universal halt decider, after
>>>>>>>>>>>> all, needs to be able to evalute *all* computations.
>>>>>>>>>>
>>>>>>>>>> So what's the answer to the actual question? How do I ask your
>>>>>>>>>> Halt decider about the behaviour P(P)_independent?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You don't because it does not know English, you translate your
>>>>>>>>> question to be about line 1,2,3 of main() and then go look up
>>>>>>>>> what I already said.
>>>>>>>>
>>>>>>>> If I want H to tell me whether P(P)_independent halts, then WHAT
>>>>>>>> THE FUCK ARGUMENT do I pass to H? This is not a difficult question.
>>>>>>>>
>>>>>>>
>>>>>>> I have no idea what you are talking about unless you are talking
>>>>>>> about the first line of main() above.
>>>>>>
>>>>>> Yes, I am talking about the first line of main. How do I ask H
>>>>>> about the behaviour of *that* computation. The one that halts and
>>>>>> which corresponds to the Linz counterexample which you claim is
>>>>>> the only case you need to get right. What argument does one give
>>>>>> to H if one wants H to tell us that that computation halts?
>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>
>>>> I'm asking about C functions. The above has nothing to do with C
>>>> functions.
>>>>
>>>
>>> You asked about the Linz counter example that <is> the Linz counter
>>> example.
>>>
>>>>
>>>> I am asking what *argument* you would pass to H in order to get it
>>>> to report on the halting behaviour of P(P) in main.
>>>>
>>>
>>> You might as well have asked:
>>> How do you convert your pet cat into a 20 story office building?
>>>
>>> H(P,P) from main and P(P) from main() are fundamentally different
>>> computations there is no conversion.
>>
>> Who said anything about 'conversion'? I'm asking what *argument* you
>> would pass to H to get it to answer about P(P). The one in main.
>>
>
> It is utterly impossible.
In which case your H is not a universal halt decider. If there are
computations that you can't even ask it about, then what good is it?
And bear in mind that you claimed the only case you actually needed to
get right was the one corresponding to the Linz counterexample. That
would be P(P) which you are now claiming your H isn't even able to
accept as an input.
>> A halt decider is supposed to be able to determine whether *any*
>> computation halts.
>>
>
> The only two equivalent computations are line 1 of main and line 2 of
No, they aren't, obviously.
> main. Line one of main halts. Line 2 of main() reports that its input
> halts.
>
> Line 3 of main is a fundamentally different computation than line 1 or
> line 2. There is nothing in the universe that can be done to make line 3
> behave line 1 or line 2 besides replacing it with line 1 or line 2.
>
>> The P(P) in main is supposedly a computation, so there *must* be a way
>> of asking your H about it.
>>
>>> To get similar behavior to P(P) of main() you execute H1(P,P) of main().
>>
>> Again, you claimed that H and H1 have identical code, so how can they
>> behave differently when given the same input?
You failed to address the above question. How do two programs with
identical code give different answers?
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-29 22:17 -0500 |
| Message-ID | <u8qdneSocIt-0LH8nZ2dnUU7-V-dnZ2d@giganews.com> |
| In reply to | #38541 |
On 8/29/2021 10:00 PM, André G. Isaak wrote:
> On 2021-08-29 20:51, olcott wrote:
>> On 8/29/2021 9:38 PM, André G. Isaak wrote:
>>> On 2021-08-29 20:14, olcott wrote:
>>>> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>>>>> On 2021-08-29 19:39, olcott wrote:
>>>>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-29 13:57, olcott wrote:
>>>>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Purely for sake of argument, lets imagine that your
>>>>>>>>>>>>> position actually makes sense (it does not, but we are
>>>>>>>>>>>>> imaging).
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>>>>> computation when it is run independently than when it is
>>>>>>>>>>>>> run as an input to your H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Lets call those hypothetical two computations
>>>>>>>>>>>>> P(P)_independent and P(P)_input.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> This is already fully addressed by line 1 and line 3 of main().
>>>>>>>>>>>> If you want to come up with different naming conventions so
>>>>>>>>>>>> that you don't have to bother understanding what I said I
>>>>>>>>>>>> will not oblige.
>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> P(P);
>>>>>>>>>>>> H1(P,P);
>>>>>>>>>>>> H(P,P);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> H1 has identical code to H.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> So how exactly do I ask your Halt decider about the
>>>>>>>>>>>>> behaviour P(P)_independent? A universal halt decider, after
>>>>>>>>>>>>> all, needs to be able to evalute *all* computations.
>>>>>>>>>>>
>>>>>>>>>>> So what's the answer to the actual question? How do I ask
>>>>>>>>>>> your Halt decider about the behaviour P(P)_independent?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You don't because it does not know English, you translate your
>>>>>>>>>> question to be about line 1,2,3 of main() and then go look up
>>>>>>>>>> what I already said.
>>>>>>>>>
>>>>>>>>> If I want H to tell me whether P(P)_independent halts, then
>>>>>>>>> WHAT THE FUCK ARGUMENT do I pass to H? This is not a difficult
>>>>>>>>> question.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I have no idea what you are talking about unless you are talking
>>>>>>>> about the first line of main() above.
>>>>>>>
>>>>>>> Yes, I am talking about the first line of main. How do I ask H
>>>>>>> about the behaviour of *that* computation. The one that halts and
>>>>>>> which corresponds to the Linz counterexample which you claim is
>>>>>>> the only case you need to get right. What argument does one give
>>>>>>> to H if one wants H to tell us that that computation halts?
>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>
>>>>> I'm asking about C functions. The above has nothing to do with C
>>>>> functions.
>>>>>
>>>>
>>>> You asked about the Linz counter example that <is> the Linz counter
>>>> example.
>>>>
>>>>>
>>>>> I am asking what *argument* you would pass to H in order to get it
>>>>> to report on the halting behaviour of P(P) in main.
>>>>>
>>>>
>>>> You might as well have asked:
>>>> How do you convert your pet cat into a 20 story office building?
>>>>
>>>> H(P,P) from main and P(P) from main() are fundamentally different
>>>> computations there is no conversion.
>>>
>>> Who said anything about 'conversion'? I'm asking what *argument* you
>>> would pass to H to get it to answer about P(P). The one in main.
>>>
>>
>> It is utterly impossible.
>
> In which case your H is not a universal halt decider. If there are
> computations that you can't even ask it about, then what good is it?
>
What parameter do you give to a square root function to get it to bake
an angel food cake?
> And bear in mind that you claimed the only case you actually needed to
> get right was the one corresponding to the Linz counterexample. That
> would be P(P) which you are now claiming your H isn't even able to
> accept as an input.
>
Your question seems quite nuts.
>>> A halt decider is supposed to be able to determine whether *any*
>>> computation halts.
>>>
>>
>> The only two equivalent computations are line 1 of main and line 2 of
>
> No, they aren't, obviously.
>
>> main. Line one of main halts. Line 2 of main() reports that its input
>> halts.
>>
>> Line 3 of main is a fundamentally different computation than line 1 or
>> line 2. There is nothing in the universe that can be done to make line
>> 3 behave line 1 or line 2 besides replacing it with line 1 or line 2.
>>
>>> The P(P) in main is supposedly a computation, so there *must* be a
>>> way of asking your H about it.
>>>
>>>> To get similar behavior to P(P) of main() you execute H1(P,P) of
>>>> main().
>>>
>>> Again, you claimed that H and H1 have identical code, so how can they
>>> behave differently when given the same input?
>
> You failed to address the above question. How do two programs with
> identical code give different answers?
>
> André
>
That is a very difficult question involving many pages of dialogue.
Most importantly it is off topic for the title of this post.
I cannot afford to tolerate diverence from the title of the post because
this is a tactic used to forever avoid addressing the point.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-08-29 21:43 -0600 |
| Message-ID | <sghk4g$v4k$1@dont-email.me> |
| In reply to | #38542 |
On 2021-08-29 21:17, olcott wrote:
> On 8/29/2021 10:00 PM, André G. Isaak wrote:
>> On 2021-08-29 20:51, olcott wrote:
>>> On 8/29/2021 9:38 PM, André G. Isaak wrote:
>>>> On 2021-08-29 20:14, olcott wrote:
>>>>> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>>>>>> On 2021-08-29 19:39, olcott wrote:
>>>>>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-29 13:57, olcott wrote:
>>>>>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Purely for sake of argument, lets imagine that your
>>>>>>>>>>>>>> position actually makes sense (it does not, but we are
>>>>>>>>>>>>>> imaging).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>>>>>> computation when it is run independently than when it is
>>>>>>>>>>>>>> run as an input to your H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Lets call those hypothetical two computations
>>>>>>>>>>>>>> P(P)_independent and P(P)_input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is already fully addressed by line 1 and line 3 of
>>>>>>>>>>>>> main().
>>>>>>>>>>>>> If you want to come up with different naming conventions so
>>>>>>>>>>>>> that you don't have to bother understanding what I said I
>>>>>>>>>>>>> will not oblige.
>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> P(P);
>>>>>>>>>>>>> H1(P,P);
>>>>>>>>>>>>> H(P,P);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> H1 has identical code to H.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> So how exactly do I ask your Halt decider about the
>>>>>>>>>>>>>> behaviour P(P)_independent? A universal halt decider,
>>>>>>>>>>>>>> after all, needs to be able to evalute *all* computations.
>>>>>>>>>>>>
>>>>>>>>>>>> So what's the answer to the actual question? How do I ask
>>>>>>>>>>>> your Halt decider about the behaviour P(P)_independent?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You don't because it does not know English, you translate
>>>>>>>>>>> your question to be about line 1,2,3 of main() and then go
>>>>>>>>>>> look up what I already said.
>>>>>>>>>>
>>>>>>>>>> If I want H to tell me whether P(P)_independent halts, then
>>>>>>>>>> WHAT THE FUCK ARGUMENT do I pass to H? This is not a difficult
>>>>>>>>>> question.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I have no idea what you are talking about unless you are
>>>>>>>>> talking about the first line of main() above.
>>>>>>>>
>>>>>>>> Yes, I am talking about the first line of main. How do I ask H
>>>>>>>> about the behaviour of *that* computation. The one that halts
>>>>>>>> and which corresponds to the Linz counterexample which you claim
>>>>>>>> is the only case you need to get right. What argument does one
>>>>>>>> give to H if one wants H to tell us that that computation halts?
>>>>>>>
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> I'm asking about C functions. The above has nothing to do with C
>>>>>> functions.
>>>>>>
>>>>>
>>>>> You asked about the Linz counter example that <is> the Linz counter
>>>>> example.
>>>>>
>>>>>>
>>>>>> I am asking what *argument* you would pass to H in order to get it
>>>>>> to report on the halting behaviour of P(P) in main.
>>>>>>
>>>>>
>>>>> You might as well have asked:
>>>>> How do you convert your pet cat into a 20 story office building?
>>>>>
>>>>> H(P,P) from main and P(P) from main() are fundamentally different
>>>>> computations there is no conversion.
>>>>
>>>> Who said anything about 'conversion'? I'm asking what *argument* you
>>>> would pass to H to get it to answer about P(P). The one in main.
>>>>
>>>
>>> It is utterly impossible.
>>
>> In which case your H is not a universal halt decider. If there are
>> computations that you can't even ask it about, then what good is it?
>>
>
> What parameter do you give to a square root function to get it to bake
> an angel food cake?
This is, of course, a ridiculous response.
A halt decider answers questions about computations.
The P(P) in main *is* allegedly a computation and therefore the *exact*
sort of thing you should be able to ask a halt decider about. It is not
some entity with of an inappropriate type such as an angel food cake.
More importantly, it is *the* computation your halt decider needs to be
able to correctly address to meet your goal of refuting Linz.
Now you claim that it isn't even possible to ask your decider about the
one computation most relevant to your stated goal.
>> And bear in mind that you claimed the only case you actually needed to
>> get right was the one corresponding to the Linz counterexample. That
>> would be P(P) which you are now claiming your H isn't even able to
>> accept as an input.
>>
>
> Your question seems quite nuts.
That would definitely require some clarification.
Asking how you get an alleged halt decider to answer about some specific
computation seems perfectly reasonable which is different from quite nuts.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-29 22:54 -0500 |
| Message-ID | <IfidnZmhJ7zvy7H8nZ2dnUU7-Q_NnZ2d@giganews.com> |
| In reply to | #38543 |
On 8/29/2021 10:43 PM, André G. Isaak wrote:
> On 2021-08-29 21:17, olcott wrote:
>> On 8/29/2021 10:00 PM, André G. Isaak wrote:
>>> On 2021-08-29 20:51, olcott wrote:
>>>> On 8/29/2021 9:38 PM, André G. Isaak wrote:
>>>>> On 2021-08-29 20:14, olcott wrote:
>>>>>> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-29 19:39, olcott wrote:
>>>>>>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-08-29 13:57, olcott wrote:
>>>>>>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Purely for sake of argument, lets imagine that your
>>>>>>>>>>>>>>> position actually makes sense (it does not, but we are
>>>>>>>>>>>>>>> imaging).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>>>>>>> computation when it is run independently than when it is
>>>>>>>>>>>>>>> run as an input to your H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Lets call those hypothetical two computations
>>>>>>>>>>>>>>> P(P)_independent and P(P)_input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is already fully addressed by line 1 and line 3 of
>>>>>>>>>>>>>> main().
>>>>>>>>>>>>>> If you want to come up with different naming conventions
>>>>>>>>>>>>>> so that you don't have to bother understanding what I said
>>>>>>>>>>>>>> I will not oblige.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> P(P);
>>>>>>>>>>>>>> H1(P,P);
>>>>>>>>>>>>>> H(P,P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H1 has identical code to H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So how exactly do I ask your Halt decider about the
>>>>>>>>>>>>>>> behaviour P(P)_independent? A universal halt decider,
>>>>>>>>>>>>>>> after all, needs to be able to evalute *all* computations.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So what's the answer to the actual question? How do I ask
>>>>>>>>>>>>> your Halt decider about the behaviour P(P)_independent?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You don't because it does not know English, you translate
>>>>>>>>>>>> your question to be about line 1,2,3 of main() and then go
>>>>>>>>>>>> look up what I already said.
>>>>>>>>>>>
>>>>>>>>>>> If I want H to tell me whether P(P)_independent halts, then
>>>>>>>>>>> WHAT THE FUCK ARGUMENT do I pass to H? This is not a
>>>>>>>>>>> difficult question.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I have no idea what you are talking about unless you are
>>>>>>>>>> talking about the first line of main() above.
>>>>>>>>>
>>>>>>>>> Yes, I am talking about the first line of main. How do I ask H
>>>>>>>>> about the behaviour of *that* computation. The one that halts
>>>>>>>>> and which corresponds to the Linz counterexample which you
>>>>>>>>> claim is the only case you need to get right. What argument
>>>>>>>>> does one give to H if one wants H to tell us that that
>>>>>>>>> computation halts?
>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> I'm asking about C functions. The above has nothing to do with C
>>>>>>> functions.
>>>>>>>
>>>>>>
>>>>>> You asked about the Linz counter example that <is> the Linz
>>>>>> counter example.
>>>>>>
>>>>>>>
>>>>>>> I am asking what *argument* you would pass to H in order to get
>>>>>>> it to report on the halting behaviour of P(P) in main.
>>>>>>>
>>>>>>
>>>>>> You might as well have asked:
>>>>>> How do you convert your pet cat into a 20 story office building?
>>>>>>
>>>>>> H(P,P) from main and P(P) from main() are fundamentally different
>>>>>> computations there is no conversion.
>>>>>
>>>>> Who said anything about 'conversion'? I'm asking what *argument*
>>>>> you would pass to H to get it to answer about P(P). The one in main.
>>>>>
>>>>
>>>> It is utterly impossible.
>>>
>>> In which case your H is not a universal halt decider. If there are
>>> computations that you can't even ask it about, then what good is it?
>>>
>>
>> What parameter do you give to a square root function to get it to bake
>> an angel food cake?
>
> This is, of course, a ridiculous response.
>
> A halt decider answers questions about computations.
>
> The P(P) in main *is* allegedly a computation and therefore the *exact*
> sort of thing you should be able to ask a halt decider about. It is not
> some entity with of an inappropriate type such as an angel food cake.
>
> More importantly, it is *the* computation your halt decider needs to be
> able to correctly address to meet your goal of refuting Linz.
>
int main()
{
P(P);
H1(P,P);
H(P,P);
}
It does correctly address this question.
All three lines of main() derive correct results.
That you expect them to behave in a certain way is merely your own error.
> Now you claim that it isn't even possible to ask your decider about the
> one computation most relevant to your stated goal.
>
>>> And bear in mind that you claimed the only case you actually needed
>>> to get right was the one corresponding to the Linz counterexample.
>>> That would be P(P) which you are now claiming your H isn't even able
>>> to accept as an input.
>>>
>>
>> Your question seems quite nuts.
>
> That would definitely require some clarification.
>
> Asking how you get an alleged halt decider to answer about some specific
> computation seems perfectly reasonable which is different from quite nuts.
>
> André
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-30 06:24 -0400 |
| Message-ID | <ql2XI.19899$Kv2.11688@fx47.iad> |
| In reply to | #38542 |
On 8/29/21 11:17 PM, olcott wrote:
> On 8/29/2021 10:00 PM, André G. Isaak wrote:
>> On 2021-08-29 20:51, olcott wrote:
>>> On 8/29/2021 9:38 PM, André G. Isaak wrote:
>>>> On 2021-08-29 20:14, olcott wrote:
>>>>> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>>>>>> On 2021-08-29 19:39, olcott wrote:
>>>>>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-29 13:57, olcott wrote:
>>>>>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Purely for sake of argument, lets imagine that your
>>>>>>>>>>>>>> position actually makes sense (it does not, but we are
>>>>>>>>>>>>>> imaging).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>>>>>> computation when it is run independently than when it is
>>>>>>>>>>>>>> run as an input to your H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Lets call those hypothetical two computations
>>>>>>>>>>>>>> P(P)_independent and P(P)_input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is already fully addressed by line 1 and line 3 of
>>>>>>>>>>>>> main().
>>>>>>>>>>>>> If you want to come up with different naming conventions so
>>>>>>>>>>>>> that you don't have to bother understanding what I said I
>>>>>>>>>>>>> will not oblige.
>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> P(P);
>>>>>>>>>>>>> H1(P,P);
>>>>>>>>>>>>> H(P,P);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> H1 has identical code to H.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> So how exactly do I ask your Halt decider about the
>>>>>>>>>>>>>> behaviour P(P)_independent? A universal halt decider,
>>>>>>>>>>>>>> after all, needs to be able to evalute *all* computations.
>>>>>>>>>>>>
>>>>>>>>>>>> So what's the answer to the actual question? How do I ask
>>>>>>>>>>>> your Halt decider about the behaviour P(P)_independent?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You don't because it does not know English, you translate
>>>>>>>>>>> your question to be about line 1,2,3 of main() and then go
>>>>>>>>>>> look up what I already said.
>>>>>>>>>>
>>>>>>>>>> If I want H to tell me whether P(P)_independent halts, then
>>>>>>>>>> WHAT THE FUCK ARGUMENT do I pass to H? This is not a difficult
>>>>>>>>>> question.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I have no idea what you are talking about unless you are
>>>>>>>>> talking about the first line of main() above.
>>>>>>>>
>>>>>>>> Yes, I am talking about the first line of main. How do I ask H
>>>>>>>> about the behaviour of *that* computation. The one that halts
>>>>>>>> and which corresponds to the Linz counterexample which you claim
>>>>>>>> is the only case you need to get right. What argument does one
>>>>>>>> give to H if one wants H to tell us that that computation halts?
>>>>>>>
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> I'm asking about C functions. The above has nothing to do with C
>>>>>> functions.
>>>>>>
>>>>>
>>>>> You asked about the Linz counter example that <is> the Linz counter
>>>>> example.
>>>>>
>>>>>>
>>>>>> I am asking what *argument* you would pass to H in order to get it
>>>>>> to report on the halting behaviour of P(P) in main.
>>>>>>
>>>>>
>>>>> You might as well have asked:
>>>>> How do you convert your pet cat into a 20 story office building?
>>>>>
>>>>> H(P,P) from main and P(P) from main() are fundamentally different
>>>>> computations there is no conversion.
>>>>
>>>> Who said anything about 'conversion'? I'm asking what *argument* you
>>>> would pass to H to get it to answer about P(P). The one in main.
>>>>
>>>
>>> It is utterly impossible.
>>
>> In which case your H is not a universal halt decider. If there are
>> computations that you can't even ask it about, then what good is it?
>>
>
> What parameter do you give to a square root function to get it to bake
> an angel food cake?
>
>> And bear in mind that you claimed the only case you actually needed to
>> get right was the one corresponding to the Linz counterexample. That
>> would be P(P) which you are now claiming your H isn't even able to
>> accept as an input.
>>
>
> Your question seems quite nuts.
>
>>>> A halt decider is supposed to be able to determine whether *any*
>>>> computation halts.
>>>>
>>>
>>> The only two equivalent computations are line 1 of main and line 2 of
>>
>> No, they aren't, obviously.
>>
>>> main. Line one of main halts. Line 2 of main() reports that its input
>>> halts.
>>>
>>> Line 3 of main is a fundamentally different computation than line 1
>>> or line 2. There is nothing in the universe that can be done to make
>>> line 3 behave line 1 or line 2 besides replacing it with line 1 or
>>> line 2.
>>>
>>>> The P(P) in main is supposedly a computation, so there *must* be a
>>>> way of asking your H about it.
>>>>
>>>>> To get similar behavior to P(P) of main() you execute H1(P,P) of
>>>>> main().
>>>>
>>>> Again, you claimed that H and H1 have identical code, so how can
>>>> they behave differently when given the same input?
>>
>> You failed to address the above question. How do two programs with
>> identical code give different answers?
>>
>> André
>>
>
> That is a very difficult question involving many pages of dialogue.
> Most importantly it is off topic for the title of this post.
>
> I cannot afford to tolerate diverence from the title of the post because
> this is a tactic used to forever avoid addressing the point.
>
YOU can't afford diverence because you are stuck in a dilema of falsehood.
You are stuck in a corner that you have made because your whole argument
is falling apart and you are running out of deceptions to try to keep it
together.
Fundamentally, you don't understand what a computation is, and since the
core of this problem is about computations, this puts you in an
untenable position.
You have claimed to learned everything you need to know from First
Principles, but the core definitions ARE the First Principles that
really matter, but you never learned them, but tried to make them up
from other ideas, which puts you out of the field.
You claim you have discovered an 'Exception to the Rule', when the rule
is a fundamental definition which doesn't allow for exceptions. You
create a 'need' for the execption by assuming the answer you want, and
figuring out what needs to be true to make that happen.
THAT IS NOT HOW LOGIC WORKS.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-30 09:02 -0500 |
| Message-ID | <1MGdnZjhwrdvebH8nZ2dnUU7-avNnZ2d@giganews.com> |
| In reply to | #38545 |
On 8/30/2021 5:24 AM, Richard Damon wrote:
> On 8/29/21 11:17 PM, olcott wrote:
>> On 8/29/2021 10:00 PM, André G. Isaak wrote:
>>> On 2021-08-29 20:51, olcott wrote:
>>>> On 8/29/2021 9:38 PM, André G. Isaak wrote:
>>>>> On 2021-08-29 20:14, olcott wrote:
>>>>>> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-29 19:39, olcott wrote:
>>>>>>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-08-29 13:57, olcott wrote:
>>>>>>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Purely for sake of argument, lets imagine that your
>>>>>>>>>>>>>>> position actually makes sense (it does not, but we are
>>>>>>>>>>>>>>> imaging).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>>>>>>> computation when it is run independently than when it is
>>>>>>>>>>>>>>> run as an input to your H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Lets call those hypothetical two computations
>>>>>>>>>>>>>>> P(P)_independent and P(P)_input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is already fully addressed by line 1 and line 3 of
>>>>>>>>>>>>>> main().
>>>>>>>>>>>>>> If you want to come up with different naming conventions so
>>>>>>>>>>>>>> that you don't have to bother understanding what I said I
>>>>>>>>>>>>>> will not oblige.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> P(P);
>>>>>>>>>>>>>> H1(P,P);
>>>>>>>>>>>>>> H(P,P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H1 has identical code to H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So how exactly do I ask your Halt decider about the
>>>>>>>>>>>>>>> behaviour P(P)_independent? A universal halt decider,
>>>>>>>>>>>>>>> after all, needs to be able to evalute *all* computations.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So what's the answer to the actual question? How do I ask
>>>>>>>>>>>>> your Halt decider about the behaviour P(P)_independent?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You don't because it does not know English, you translate
>>>>>>>>>>>> your question to be about line 1,2,3 of main() and then go
>>>>>>>>>>>> look up what I already said.
>>>>>>>>>>>
>>>>>>>>>>> If I want H to tell me whether P(P)_independent halts, then
>>>>>>>>>>> WHAT THE FUCK ARGUMENT do I pass to H? This is not a difficult
>>>>>>>>>>> question.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I have no idea what you are talking about unless you are
>>>>>>>>>> talking about the first line of main() above.
>>>>>>>>>
>>>>>>>>> Yes, I am talking about the first line of main. How do I ask H
>>>>>>>>> about the behaviour of *that* computation. The one that halts
>>>>>>>>> and which corresponds to the Linz counterexample which you claim
>>>>>>>>> is the only case you need to get right. What argument does one
>>>>>>>>> give to H if one wants H to tell us that that computation halts?
>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> I'm asking about C functions. The above has nothing to do with C
>>>>>>> functions.
>>>>>>>
>>>>>>
>>>>>> You asked about the Linz counter example that <is> the Linz counter
>>>>>> example.
>>>>>>
>>>>>>>
>>>>>>> I am asking what *argument* you would pass to H in order to get it
>>>>>>> to report on the halting behaviour of P(P) in main.
>>>>>>>
>>>>>>
>>>>>> You might as well have asked:
>>>>>> How do you convert your pet cat into a 20 story office building?
>>>>>>
>>>>>> H(P,P) from main and P(P) from main() are fundamentally different
>>>>>> computations there is no conversion.
>>>>>
>>>>> Who said anything about 'conversion'? I'm asking what *argument* you
>>>>> would pass to H to get it to answer about P(P). The one in main.
>>>>>
>>>>
>>>> It is utterly impossible.
>>>
>>> In which case your H is not a universal halt decider. If there are
>>> computations that you can't even ask it about, then what good is it?
>>>
>>
>> What parameter do you give to a square root function to get it to bake
>> an angel food cake?
>>
>>> And bear in mind that you claimed the only case you actually needed to
>>> get right was the one corresponding to the Linz counterexample. That
>>> would be P(P) which you are now claiming your H isn't even able to
>>> accept as an input.
>>>
>>
>> Your question seems quite nuts.
>>
>>>>> A halt decider is supposed to be able to determine whether *any*
>>>>> computation halts.
>>>>>
>>>>
>>>> The only two equivalent computations are line 1 of main and line 2 of
>>>
>>> No, they aren't, obviously.
>>>
>>>> main. Line one of main halts. Line 2 of main() reports that its input
>>>> halts.
>>>>
>>>> Line 3 of main is a fundamentally different computation than line 1
>>>> or line 2. There is nothing in the universe that can be done to make
>>>> line 3 behave line 1 or line 2 besides replacing it with line 1 or
>>>> line 2.
>>>>
>>>>> The P(P) in main is supposedly a computation, so there *must* be a
>>>>> way of asking your H about it.
>>>>>
>>>>>> To get similar behavior to P(P) of main() you execute H1(P,P) of
>>>>>> main().
>>>>>
>>>>> Again, you claimed that H and H1 have identical code, so how can
>>>>> they behave differently when given the same input?
>>>
>>> You failed to address the above question. How do two programs with
>>> identical code give different answers?
>>>
>>> André
>>>
>>
>> That is a very difficult question involving many pages of dialogue.
>> Most importantly it is off topic for the title of this post.
>>
>> I cannot afford to tolerate diverence from the title of the post because
>> this is a tactic used to forever avoid addressing the point.
>>
>
> YOU can't afford diverence because you are stuck in a dilema of falsehood.
>
Ĵ copies its input ⟨Ĵ1⟩ to ⟨Ĵ2⟩ then simulates this input Ĵ1 with its
input ⟨Ĵ2⟩
which copies its input ⟨Ĵ2⟩ to ⟨Ĵ3⟩ then simulates this input Ĵ2 with
its input ⟨Ĵ3⟩
which copies its input ⟨Ĵ3⟩ to ⟨Ĵ4⟩ then simulates this input Ĵ3 with
its input ⟨Ĵ4⟩ ...
It took Ben four years to acknowledge that Ĵ never halts on its input
⟨Ĵ⟩ because I tolerated him changing the subject instead of requiring
him to stay focused on the point at hand. I will no longer tolerate
these dishonest dodges from anyone. You and André are doing the same thing.
Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ halts, and
Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ does not halt
It is still the case that none of my dishonest reviewers will not
acknowledge that while the simulating halt decider at Ĥ.qx acts like a
UTM that Ĥ applied to ⟨Ĥ⟩ never halts.
> You are stuck in a corner that you have made because your whole argument
> is falling apart and you are running out of deceptions to try to keep it
> together.
>
> Fundamentally, you don't understand what a computation is, and since the
> core of this problem is about computations, this puts you in an
> untenable position.
>
> You have claimed to learned everything you need to know from First
> Principles, but the core definitions ARE the First Principles that
> really matter, but you never learned them, but tried to make them up
> from other ideas, which puts you out of the field.
>
> You claim you have discovered an 'Exception to the Rule', when the rule
> is a fundamental definition which doesn't allow for exceptions. You
> create a 'need' for the execption by assuming the answer you want, and
> figuring out what needs to be true to make that happen.
>
> THAT IS NOT HOW LOGIC WORKS.
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-30 20:13 -0400 |
| Message-ID | <3veXI.5806$%Z2.868@fx06.iad> |
| In reply to | #38547 |
On 8/30/21 10:02 AM, olcott wrote:
> On 8/30/2021 5:24 AM, Richard Damon wrote:
>> On 8/29/21 11:17 PM, olcott wrote:
>>> On 8/29/2021 10:00 PM, André G. Isaak wrote:
>>>> On 2021-08-29 20:51, olcott wrote:
>>>>> On 8/29/2021 9:38 PM, André G. Isaak wrote:
>>>>>> On 2021-08-29 20:14, olcott wrote:
>>>>>>> On 8/29/2021 8:54 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-29 19:39, olcott wrote:
>>>>>>>>> On 8/29/2021 5:16 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-08-29 13:57, olcott wrote:
>>>>>>>>>>> On 8/29/2021 2:48 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-08-29 13:40, olcott wrote:
>>>>>>>>>>>>> On 8/29/2021 2:32 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-08-29 12:53, olcott wrote:
>>>>>>>>>>>>>>> On 8/28/2021 7:42 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>> On 2021-08-28 17:51, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I will take this to mean that you already know that
>>>>>>>>>>>>>>>>> That P(P) of main() halts does not contradict H(P,P)==0.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Purely for sake of argument, lets imagine that your
>>>>>>>>>>>>>>>> position actually makes sense (it does not, but we are
>>>>>>>>>>>>>>>> imaging).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are trying to claim that P(P) represents a different
>>>>>>>>>>>>>>>> computation when it is run independently than when it is
>>>>>>>>>>>>>>>> run as an input to your H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Lets call those hypothetical two computations
>>>>>>>>>>>>>>>> P(P)_independent and P(P)_input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is already fully addressed by line 1 and line 3 of
>>>>>>>>>>>>>>> main().
>>>>>>>>>>>>>>> If you want to come up with different naming conventions so
>>>>>>>>>>>>>>> that you don't have to bother understanding what I said I
>>>>>>>>>>>>>>> will not oblige.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> P(P);
>>>>>>>>>>>>>>> H1(P,P);
>>>>>>>>>>>>>>> H(P,P);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H1 has identical code to H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So how exactly do I ask your Halt decider about the
>>>>>>>>>>>>>>>> behaviour P(P)_independent? A universal halt decider,
>>>>>>>>>>>>>>>> after all, needs to be able to evalute *all* computations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So what's the answer to the actual question? How do I ask
>>>>>>>>>>>>>> your Halt decider about the behaviour P(P)_independent?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You don't because it does not know English, you translate
>>>>>>>>>>>>> your question to be about line 1,2,3 of main() and then go
>>>>>>>>>>>>> look up what I already said.
>>>>>>>>>>>>
>>>>>>>>>>>> If I want H to tell me whether P(P)_independent halts, then
>>>>>>>>>>>> WHAT THE FUCK ARGUMENT do I pass to H? This is not a difficult
>>>>>>>>>>>> question.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I have no idea what you are talking about unless you are
>>>>>>>>>>> talking about the first line of main() above.
>>>>>>>>>>
>>>>>>>>>> Yes, I am talking about the first line of main. How do I ask H
>>>>>>>>>> about the behaviour of *that* computation. The one that halts
>>>>>>>>>> and which corresponds to the Linz counterexample which you claim
>>>>>>>>>> is the only case you need to get right. What argument does one
>>>>>>>>>> give to H if one wants H to tell us that that computation halts?
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> I'm asking about C functions. The above has nothing to do with C
>>>>>>>> functions.
>>>>>>>>
>>>>>>>
>>>>>>> You asked about the Linz counter example that <is> the Linz counter
>>>>>>> example.
>>>>>>>
>>>>>>>>
>>>>>>>> I am asking what *argument* you would pass to H in order to get it
>>>>>>>> to report on the halting behaviour of P(P) in main.
>>>>>>>>
>>>>>>>
>>>>>>> You might as well have asked:
>>>>>>> How do you convert your pet cat into a 20 story office building?
>>>>>>>
>>>>>>> H(P,P) from main and P(P) from main() are fundamentally different
>>>>>>> computations there is no conversion.
>>>>>>
>>>>>> Who said anything about 'conversion'? I'm asking what *argument* you
>>>>>> would pass to H to get it to answer about P(P). The one in main.
>>>>>>
>>>>>
>>>>> It is utterly impossible.
>>>>
>>>> In which case your H is not a universal halt decider. If there are
>>>> computations that you can't even ask it about, then what good is it?
>>>>
>>>
>>> What parameter do you give to a square root function to get it to bake
>>> an angel food cake?
>>>
>>>> And bear in mind that you claimed the only case you actually needed to
>>>> get right was the one corresponding to the Linz counterexample. That
>>>> would be P(P) which you are now claiming your H isn't even able to
>>>> accept as an input.
>>>>
>>>
>>> Your question seems quite nuts.
>>>
>>>>>> A halt decider is supposed to be able to determine whether *any*
>>>>>> computation halts.
>>>>>>
>>>>>
>>>>> The only two equivalent computations are line 1 of main and line 2 of
>>>>
>>>> No, they aren't, obviously.
>>>>
>>>>> main. Line one of main halts. Line 2 of main() reports that its input
>>>>> halts.
>>>>>
>>>>> Line 3 of main is a fundamentally different computation than line 1
>>>>> or line 2. There is nothing in the universe that can be done to make
>>>>> line 3 behave line 1 or line 2 besides replacing it with line 1 or
>>>>> line 2.
>>>>>
>>>>>> The P(P) in main is supposedly a computation, so there *must* be a
>>>>>> way of asking your H about it.
>>>>>>
>>>>>>> To get similar behavior to P(P) of main() you execute H1(P,P) of
>>>>>>> main().
>>>>>>
>>>>>> Again, you claimed that H and H1 have identical code, so how can
>>>>>> they behave differently when given the same input?
>>>>
>>>> You failed to address the above question. How do two programs with
>>>> identical code give different answers?
>>>>
>>>> André
>>>>
>>>
>>> That is a very difficult question involving many pages of dialogue.
>>> Most importantly it is off topic for the title of this post.
>>>
>>> I cannot afford to tolerate diverence from the title of the post because
>>> this is a tactic used to forever avoid addressing the point.
>>>
>>
>> YOU can't afford diverence because you are stuck in a dilema of
>> falsehood.
>>
>
> Ĵ copies its input ⟨Ĵ1⟩ to ⟨Ĵ2⟩ then simulates this input Ĵ1 with its
> input ⟨Ĵ2⟩
> which copies its input ⟨Ĵ2⟩ to ⟨Ĵ3⟩ then simulates this input Ĵ2 with
> its input ⟨Ĵ3⟩
> which copies its input ⟨Ĵ3⟩ to ⟨Ĵ4⟩ then simulates this input Ĵ3 with
> its input ⟨Ĵ4⟩ ...
>
Strawman, I NEVER said J^ is Halting, only the H^ based on an H that
returns non-halting is claimed Halting. The versions built on an H that
doesn't abort (Hn) can be non-halting as Hn never gives an answer to
Hn(<Hn^>,<Hn^>)
> It took Ben four years to acknowledge that Ĵ never halts on its input
> ⟨Ĵ⟩ because I tolerated him changing the subject instead of requiring
> him to stay focused on the point at hand. I will no longer tolerate
> these dishonest dodges from anyone. You and André are doing the same thing.
Nope, I NEVER said that an H^ based on a non-aborting H wouldn't be
non-halting, only that an H^ based on an H that returns non-Halting, and
that it was incorrect to conflate the two cases.
>
> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ halts, and
>
> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ does not halt
>
> It is still the case that none of my dishonest reviewers will not
> acknowledge that while the simulating halt decider at Ĥ.qx acts like a
> UTM that Ĥ applied to ⟨Ĥ⟩ never halts.
Since we KNOW that H(<H^>,<H^>) returns non-halting, and that H^(<H^>)
is halting, we know that U(<H^1>,<H^2>) will halt and thus H^.q0 (<H^1>)
SHOULD end up in qy, but it seems that it ends up at qn.
If you want to claim that Simulated <H^1>, <H^2> doesn't halt while
running H^(<H^>) does, you need to explain what happens.
Is <H^1> or <H^2> NOT actually representations of H^? Then you have
something wrong in the implementation of this machine, as it should be.
<H^0> was supposed to be the representation of H^, and the copies were
supposed to be exact, so if they differ you H^ is built wrong.
Is a simulated copy of H(H^,H^) somehow different than the actual
running of H(H^,H^), in which case either your simulator is broken or H
is not a computation, and thus not possible a Decider.
>
>> You are stuck in a corner that you have made because your whole argument
>> is falling apart and you are running out of deceptions to try to keep it
>> together.
>>
>> Fundamentally, you don't understand what a computation is, and since the
>> core of this problem is about computations, this puts you in an
>> untenable position.
>>
>> You have claimed to learned everything you need to know from First
>> Principles, but the core definitions ARE the First Principles that
>> really matter, but you never learned them, but tried to make them up
>> from other ideas, which puts you out of the field.
>>
>> You claim you have discovered an 'Exception to the Rule', when the rule
>> is a fundamental definition which doesn't allow for exceptions. You
>> create a 'need' for the execption by assuming the answer you want, and
>> figuring out what needs to be true to make that happen.
>>
>> THAT IS NOT HOW LOGIC WORKS.
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-08-31 03:12 +0100 |
| Message-ID | <87fsuq5plp.fsf@bsb.me.uk> |
| In reply to | #38547 |
olcott <NoOne@NoWhere.com> writes: > It took Ben four years to acknowledge that Ĵ never halts on its input > ⟨Ĵ⟩ because I tolerated him changing the subject instead of requiring > him to stay focused on the point at hand. Liar. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-30 21:30 -0500 |
| Message-ID | <7fudnRn17L-sCbD8nZ2dnUU7-cudnZ2d@giganews.com> |
| In reply to | #38568 |
On 8/30/2021 9:12 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> It took Ben four years to acknowledge that Ĵ never halts on its input >> ⟨Ĵ⟩ because I tolerated him changing the subject instead of requiring >> him to stay focused on the point at hand. > > Liar. > Here is where I first brought it up. you find where you first agreed: On 3/11/2017 3:13 PM, peteolcott wrote: > http://LiarParadox.org/HP_Infinite_Recursion.pdf > > As this page 319 of An Introduction to Formal Languages and Automata > by Peter Linz 1990 indicates > > From H' we construct another Turing machine H-Hat. This new machine takes as input Wm, copies it then behaves exactly like H'. > > q0 Wm |-* H-Hat q0 Wm Wm... > > Page 320 indicates that we apply H-Hat to itself as input. > > The problem is that every H-Hat needs a pair of inputs. > > H-Hat takes an H-Hat as input and copies it so that it > can analyze how its input H-hat would analyze the copy > of H-Hat that it just made. > > The input H-Hat would have to copy its own input H-Hat > so that it can analyze what its own input H-Hat would > do on its own input, on and on forever... > > Copyright 2016 and 2017 Pete Olcott. > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 5 of 37 — ← Prev page 1 … 3 4 [5] 6 7 … 37 Next page →
Back to top | Article view | comp.theory
csiph-web