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 3 of 37 — ← Prev page 1 2 [3] 4 5 … 37 Next page →
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-08-31 12:40 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <sglt23$2au$1@dont-email.me> |
| In reply to | #38608 |
On 2021-08-31 11:55, olcott wrote: > On 8/31/2021 12:00 PM, André G. Isaak wrote: >> On 2021-08-31 10:49, olcott wrote: >>> On 8/31/2021 11:31 AM, André G. Isaak wrote: >>> The halting problem is always about program descriptions >>> not running programs. This means that it is always about >>> the input to the halt decider not the direct execution >>> of the program. >> >> The input to the halt decider is simply data. Data doesn't halt or not >> halt. Only the thing described by the data can be referred to as >> halting or not halting. And that thing is the actual computation. >> > > The halt decider must base its halting decision on the invocation order > specified by its actual input not some other entirely different > computation. The actual input is P, P That specifies the computation P(P) It makes no reference at all to the "relative invocation order" of H with respect to P. It makes no reference to H at all. If its answer doesn't correspond to the behaviour of P(P) which is a halting computation, then its answer is *wrong*. >>>> Think about it. What is the whole point of asking whether a >>>> universal halt decider is possible? It's because the existence of a >>>> such a decider would allow us to solve a wide variety of previously >>>> unsolved problems. >>>> >>>> If we want to know whether some computation, say P(P) halts, we want >>>> to know about the *actual* computation. Why on earth would anyone >>>> even care how it behaves in a particular simulating halt decider? >>>> That behaviour is tied to the specific decider and therefore isn't a >>>> property of the computation we're asking about. So what possible >>>> interest could it be to anyone? >> >> You didn't answer the above. If you actually spend some time thinking >> about it you might realize why your position is entirely ridiculous. >> Why would anyone even think to ask the question which you are >> mistaking for the halting problem? Again, you still haven't answered the above. Why should anyone, anywhere actually *care* about what happens with some simulation tied to a specific halt decider? What possible relevance could this have to any problem? -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-31 14:11 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <5omdnbGCF59547P8nZ2dnUU7-XnNnZ2d@giganews.com> |
| In reply to | #38609 |
On 8/31/2021 1:40 PM, André G. Isaak wrote:
> On 2021-08-31 11:55, olcott wrote:
>> On 8/31/2021 12:00 PM, André G. Isaak wrote:
>>> On 2021-08-31 10:49, olcott wrote:
>>>> On 8/31/2021 11:31 AM, André G. Isaak wrote:
>
>>>> The halting problem is always about program descriptions
>>>> not running programs. This means that it is always about
>>>> the input to the halt decider not the direct execution
>>>> of the program.
>>>
>>> The input to the halt decider is simply data. Data doesn't halt or
>>> not halt. Only the thing described by the data can be referred to as
>>> halting or not halting. And that thing is the actual computation.
>>>
>>
>> The halt decider must base its halting decision on the invocation
>> order specified by its actual input not some other entirely different
>> computation.
>
> The actual input is P, P
>
> That specifies the computation P(P)
>
> It makes no reference at all to the "relative invocation order" of H
> with respect to P. It makes no reference to H at all.
>
> If its answer doesn't correspond to the behaviour of P(P) which is a
> halting computation, then its answer is *wrong*.
H(P,P) specifies the invocation order of H(P,P) then P(P).
If P did not have the pathological self-reference error the invocation
would not matter. Because P does have the pathological self-reference
error the invocation order does matter.
It is very diffcult to correctly handle incorrect input.
The key irrefutable point is that H(P,P) then P(P) is an entirely
different computation than P(P) then H(P,P) thus the fact that int
main() { P(P); } halts does not contradict that H(P,P) correctly decides
that its input never halts.
>>>>> Think about it. What is the whole point of asking whether a
>>>>> universal halt decider is possible? It's because the existence of a
>>>>> such a decider would allow us to solve a wide variety of previously
>>>>> unsolved problems.
>>>>>
>>>>> If we want to know whether some computation, say P(P) halts, we
>>>>> want to know about the *actual* computation. Why on earth would
>>>>> anyone even care how it behaves in a particular simulating halt
>>>>> decider? That behaviour is tied to the specific decider and
>>>>> therefore isn't a property of the computation we're asking about.
>>>>> So what possible interest could it be to anyone?
>>>
>>> You didn't answer the above. If you actually spend some time thinking
>>> about it you might realize why your position is entirely ridiculous.
>>> Why would anyone even think to ask the question which you are
>>> mistaking for the halting problem?
>
> Again, you still haven't answered the above. Why should anyone, anywhere
> actually *care* about what happens with some simulation tied to a
> specific halt decider? What possible relevance could this have to any
> problem?
>
This refutes the halting problem proofs:
Simulating Halt Decider Theorem (Olcott 2020):
A simulating halt decider correctly decides that any input that never
halts unless the simulating halt decider aborts its simulation of this
input is an input that never halts.
The above is verified as completely true entirely on the basis of the
meaning of its words.
--
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-31 14:08 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <sgm28i$783$1@dont-email.me> |
| In reply to | #38610 |
On 2021-08-31 13:11, olcott wrote:
> On 8/31/2021 1:40 PM, André G. Isaak wrote:
>> On 2021-08-31 11:55, olcott wrote:
>>> On 8/31/2021 12:00 PM, André G. Isaak wrote:
>>>> On 2021-08-31 10:49, olcott wrote:
>>>>> On 8/31/2021 11:31 AM, André G. Isaak wrote:
>>
>>>>> The halting problem is always about program descriptions
>>>>> not running programs. This means that it is always about
>>>>> the input to the halt decider not the direct execution
>>>>> of the program.
>>>>
>>>> The input to the halt decider is simply data. Data doesn't halt or
>>>> not halt. Only the thing described by the data can be referred to as
>>>> halting or not halting. And that thing is the actual computation.
>>>>
>>>
>>> The halt decider must base its halting decision on the invocation
>>> order specified by its actual input not some other entirely different
>>> computation.
>>
>> The actual input is P, P
>>
>> That specifies the computation P(P)
>>
>> It makes no reference at all to the "relative invocation order" of H
>> with respect to P. It makes no reference to H at all.
>>
>> If its answer doesn't correspond to the behaviour of P(P) which is a
>> halting computation, then its answer is *wrong*.
>
> H(P,P) specifies the invocation order of H(P,P) then P(P).
H is allegedly a TM which determines whether the computation described
by its *input* halts.
The input to H(P, P) does *not* include H. The input specifies P(P).
Nothing about H. Nothing about the invocation order of H(P, P). It is
supposed to tell us about the behaviour of the computation P(P)
That means the *independent* computation P(P)
Not P(P) being invoked inside H.
Not P(P) being simulated by anything.
The *independent* computation P(P)
Since you don't even grasp the *question* that a Halt Decider is
supposed to answer, then you probably shouldn't work on them. Maybe take
up macramé or colouring books.
> If P did not have the pathological self-reference error the invocation
> would not matter. Because P does have the pathological self-reference
> error the invocation order does matter.
There is no self-reference in P. At least not if it corresponds to
Linz's H_Hat. Until you actually learn what 'self-reference' means, you
probably shouldn't insist on finding it everywhere.
> It is very diffcult to correctly handle incorrect input.
There's nothing incorrect about (P, P) as an input.
> The key irrefutable point is that H(P,P) then P(P) is an entirely
> different computation than P(P) then H(P,P) thus the fact that int
Yes, they are separate computations. But H(P, P) is being asked about
P(P), not about H(P, P).
If you want it to tell you about H(P, P) then you need to call H(H, P, P).
> main() { P(P); } halts does not contradict that H(P,P) correctly decides
> that its input never halts.
Of course it does because its input, (P, P) *describes* int main() { P(P); }
That's the computation whose behaviour it is supposed to tell us about.
It isn't supposed to tell us about H(P, P). Do you not understand the
distinction between a function and an argument to that function?
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-31 16:34 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <oeidnZhXEJ3iPbP8nZ2dnUU7-UvNnZ2d@giganews.com> |
| In reply to | #38611 |
On 8/31/2021 3:08 PM, André G. Isaak wrote:
> On 2021-08-31 13:11, olcott wrote:
>> On 8/31/2021 1:40 PM, André G. Isaak wrote:
>>> On 2021-08-31 11:55, olcott wrote:
>>>> On 8/31/2021 12:00 PM, André G. Isaak wrote:
>>>>> On 2021-08-31 10:49, olcott wrote:
>>>>>> On 8/31/2021 11:31 AM, André G. Isaak wrote:
>>>
>>>>>> The halting problem is always about program descriptions
>>>>>> not running programs. This means that it is always about
>>>>>> the input to the halt decider not the direct execution
>>>>>> of the program.
>>>>>
>>>>> The input to the halt decider is simply data. Data doesn't halt or
>>>>> not halt. Only the thing described by the data can be referred to
>>>>> as halting or not halting. And that thing is the actual computation.
>>>>>
>>>>
>>>> The halt decider must base its halting decision on the invocation
>>>> order specified by its actual input not some other entirely
>>>> different computation.
>>>
>>> The actual input is P, P
>>>
>>> That specifies the computation P(P)
>>>
>>> It makes no reference at all to the "relative invocation order" of H
>>> with respect to P. It makes no reference to H at all.
>>>
>>> If its answer doesn't correspond to the behaviour of P(P) which is a
>>> halting computation, then its answer is *wrong*.
>>
>> H(P,P) specifies the invocation order of H(P,P) then P(P).
>
> H is allegedly a TM which determines whether the computation described
> by its *input* halts.
>
Yes.
// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
int main()
{
Output("Input_Halts = ", H((u32)P, (u32)P));
}
> The input to H(P, P) does *not* include H.
When P calls H then H becomes input to H.
> The input specifies P(P).
> Nothing about H. Nothing about the invocation order of H(P, P). It is
> supposed to tell us about the behaviour of the computation P(P)
>
> That means the *independent* computation P(P)
>
When P calls H then H becomes input to H and a dependency is formed.
Because of this erroneous pathological self-reference dependency the
different execution order of P(P) then H(P,P) compared to H(P,P) then
P(P) defines two distinct computations such that opposite behavior of
one does not contradict the other.
> Not P(P) being invoked inside H.
>
That H calls P which in turn calls H must be separately accounted for
and treated differently.
> Not P(P) being simulated by anything.
>
> The *independent* computation P(P)
>
There is no independent computation.
We either have P(P) dependent on H(P,P)
or we have H(P,P) dependent on P(P);
> Since you don't even grasp the *question* that a Halt Decider is
> supposed to answer, then you probably shouldn't work on them. Maybe take
> up macramé or colouring books.
>
>> If P did not have the pathological self-reference error the invocation
>> would not matter. Because P does have the pathological self-reference
>> error the invocation order does matter.
>
> There is no self-reference in P. At least not if it corresponds to
> Linz's H_Hat. Until you actually learn what 'self-reference' means, you
> probably shouldn't insist on finding it everywhere.
https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
The Linz conclusion is entirely based on Ĥ applied to its own Turing
machine description. (Top paragraph of page 320)
That you didn't even know this should be sufficient proof that you
simply flat out don't know these things as well as you claim.
Ĥ applied to ⟨Ĥ⟩ is self-reference.
>
>> It is very diffcult to correctly handle incorrect input.
>
> There's nothing incorrect about (P, P) as an input.
>
>> The key irrefutable point is that H(P,P) then P(P) is an entirely
>> different computation than P(P) then H(P,P) thus the fact that int
>
> Yes, they are separate computations. But H(P, P) is being asked about
> P(P), not about H(P, P).
>
It is being asked about its input therefore it is being asked about the
invocation order of H(P,P) then P() it is not being asked about P(P)
than H(P,P).
If we want to ask about the invocation order of P(P) we need another
halt decider that is not involved in the pathological self-reference error.
With H1(P,P) we have the same invocation order as int main() { P(P); }.
This would be the same as the original Linz H applied to ⟨Ĥ⟩.
Both H1 and H report that their input halts on its input
> If you want it to tell you about H(P, P) then you need to call H(H, P, P).
>
// H2 take two parameters and reports that its input halts.
Output("Input_Halts = ", H2((u32)H, (u32)P, (u32)P));
>> main() { P(P); } halts does not contradict that H(P,P) correctly
>> decides that its input never halts.
>
> Of course it does because its input, (P, P) *describes* int main() {
> P(P); }
>
// It does not. This one does, and it reports that its input halts.
Output("Input_Halts = ", H1((u32)P, (u32)P));
> That's the computation whose behaviour it is supposed to tell us about.
>
> It isn't supposed to tell us about H(P, P). Do you not understand the
> distinction between a function and an argument to that function?
>
> 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-31 16:40 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <sgmb42$fk$1@dont-email.me> |
| In reply to | #38614 |
On 2021-08-31 15:34, olcott wrote:
> On 8/31/2021 3:08 PM, André G. Isaak wrote:
>> On 2021-08-31 13:11, olcott wrote:
>>> On 8/31/2021 1:40 PM, André G. Isaak wrote:
>>>> On 2021-08-31 11:55, olcott wrote:
>>>>> On 8/31/2021 12:00 PM, André G. Isaak wrote:
>>>>>> On 2021-08-31 10:49, olcott wrote:
>>>>>>> On 8/31/2021 11:31 AM, André G. Isaak wrote:
>>>>
>>>>>>> The halting problem is always about program descriptions
>>>>>>> not running programs. This means that it is always about
>>>>>>> the input to the halt decider not the direct execution
>>>>>>> of the program.
>>>>>>
>>>>>> The input to the halt decider is simply data. Data doesn't halt or
>>>>>> not halt. Only the thing described by the data can be referred to
>>>>>> as halting or not halting. And that thing is the actual computation.
>>>>>>
>>>>>
>>>>> The halt decider must base its halting decision on the invocation
>>>>> order specified by its actual input not some other entirely
>>>>> different computation.
>>>>
>>>> The actual input is P, P
>>>>
>>>> That specifies the computation P(P)
>>>>
>>>> It makes no reference at all to the "relative invocation order" of H
>>>> with respect to P. It makes no reference to H at all.
>>>>
>>>> If its answer doesn't correspond to the behaviour of P(P) which is a
>>>> halting computation, then its answer is *wrong*.
>>>
>>> H(P,P) specifies the invocation order of H(P,P) then P(P).
>>
>> H is allegedly a TM which determines whether the computation described
>> by its *input* halts.
>>
>
> Yes.
>
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
>
>> The input to H(P, P) does *not* include H.
>
> When P calls H then H becomes input to H.
No, it doesn't. The only inputs to H are (P, P)
That P makes a call to H doesn't make H an input in the above case any
more than P calling any other function would make that function an input
to H.
The input to H is a *computation*. Anything inside that computation is
*part* of that computation, not some distinct input to H
>> The input specifies P(P). Nothing about H. Nothing about the
>> invocation order of H(P, P). It is supposed to tell us about the
>> behaviour of the computation P(P)
>>
>> That means the *independent* computation P(P)
>>
>
> When P calls H then H becomes input to H and a dependency is formed.
>
> Because of this erroneous pathological self-reference dependency the
> different execution order of P(P) then H(P,P) compared to H(P,P) then
> P(P) defines two distinct computations such that opposite behavior of
> one does not contradict the other.
>
>> Not P(P) being invoked inside H.
>>
>
> That H calls P which in turn calls H must be separately accounted for
> and treated differently.
>
>> Not P(P) being simulated by anything.
>>
>> The *independent* computation P(P)
>>
>
> There is no independent computation.
Of course there is.
What you insist on referring to by the overly verbose name int main() {
P(P); } is the independent computation. The fact that P(P) calls other
functions doesn't make it cease to be an independent computation.
> We either have P(P) dependent on H(P,P)
> or we have H(P,P) dependent on P(P);
>
>> Since you don't even grasp the *question* that a Halt Decider is
>> supposed to answer, then you probably shouldn't work on them. Maybe
>> take up macramé or colouring books.
>>
>>> If P did not have the pathological self-reference error the
>>> invocation would not matter. Because P does have the pathological
>>> self-reference error the invocation order does matter.
>>
>> There is no self-reference in P. At least not if it corresponds to
>> Linz's H_Hat. Until you actually learn what 'self-reference' means,
>> you probably shouldn't insist on finding it everywhere.
>
> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
> The Linz conclusion is entirely based on Ĥ applied to its own Turing
> machine description. (Top paragraph of page 320)
Yes. H_Hat is passed a *description* of a Turing Machine plus an input.
In other words, it is passed a *string*.
There would only be self-reference if H_Hat accepted *itself* as an
input, which of course is not possible since you can't place a Turing
Machine on a tape.
X(Description_of_X) is not self-reference.
X(Myself) would be self-reference, and the syntax of most formal
languages simply don't allow this.
> That you didn't even know this should be sufficient proof that you
> simply flat out don't know these things as well as you claim.
>
> Ĥ applied to ⟨Ĥ⟩ is self-reference.
No, it is not. (H_Hat) is a complete description of a Turing Machine. It
does not *refer* at all.
Do you understand what "refer" means?
>>
>>> It is very diffcult to correctly handle incorrect input.
>>
>> There's nothing incorrect about (P, P) as an input.
>>
>>> The key irrefutable point is that H(P,P) then P(P) is an entirely
>>> different computation than P(P) then H(P,P) thus the fact that int
>>
>> Yes, they are separate computations. But H(P, P) is being asked about
>> P(P), not about H(P, P).
>>
>
> It is being asked about its input therefore it is being asked about the
> invocation order of H(P,P) then P() it is not being asked about P(P)
> than H(P,P). >
> If we want to ask about the invocation order of P(P) we need another
> halt decider that is not involved in the pathological self-reference error.
The above is simply an incoherent mess. The input given to H says
nothing whatsoever about 'invocation orders' H is given two parameters:
P and P.
If 'invocation orders' makes a difference to how things work and your H
imposes some 'invocation order' which is different from whatever is
found in the independent computation P(P), that simply indicates that
your H is broken. It fails to meet the specifications of a halt decider
which is *required* to describe the behaviour of the *independent*
computation described by its input.
> With H1(P,P) we have the same invocation order as int main() { P(P); }.
Until you explain what H1 is, the above conveys no information. All
you've claimed is that H1 is identical to H yet mysteriously gives a
different answer from H.
> This would be the same as the original Linz H applied to ⟨Ĥ⟩.
> Both H1 and H report that their input halts on its input
???
You've gone to great lengths to justify as correct the fact that your
H(P, P) claims that its input *doesn't* halt. Now you claim H reports
that it does halt? You really need to make up your mind.
>> If you want it to tell you about H(P, P) then you need to call H(H, P,
>> P).
>>
>
> // H2 take two parameters and reports that its input halts.
> Output("Input_Halts = ", H2((u32)H, (u32)P, (u32)P));
>
>>> main() { P(P); } halts does not contradict that H(P,P) correctly
>>> decides that its input never halts.
>>
>> Of course it does because its input, (P, P) *describes* int main() {
>> P(P); }
>>
>
> // It does not. This one does, and it reports that its input halts.
> Output("Input_Halts = ", H1((u32)P, (u32)P));
So where is the code for this mysterious H1?
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-31 18:29 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <aKednd3Gm7fVJrP8nZ2dnUU7-KPNnZ2d@giganews.com> |
| In reply to | #38616 |
On 8/31/2021 5:40 PM, André G. Isaak wrote:
> On 2021-08-31 15:34, olcott wrote:
>> On 8/31/2021 3:08 PM, André G. Isaak wrote:
>>> On 2021-08-31 13:11, olcott wrote:
>>>> On 8/31/2021 1:40 PM, André G. Isaak wrote:
>>>>> On 2021-08-31 11:55, olcott wrote:
>>>>>> On 8/31/2021 12:00 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-31 10:49, olcott wrote:
>>>>>>>> On 8/31/2021 11:31 AM, André G. Isaak wrote:
>>>>>
>>>>>>>> The halting problem is always about program descriptions
>>>>>>>> not running programs. This means that it is always about
>>>>>>>> the input to the halt decider not the direct execution
>>>>>>>> of the program.
>>>>>>>
>>>>>>> The input to the halt decider is simply data. Data doesn't halt
>>>>>>> or not halt. Only the thing described by the data can be referred
>>>>>>> to as halting or not halting. And that thing is the actual
>>>>>>> computation.
>>>>>>>
>>>>>>
>>>>>> The halt decider must base its halting decision on the invocation
>>>>>> order specified by its actual input not some other entirely
>>>>>> different computation.
>>>>>
>>>>> The actual input is P, P
>>>>>
>>>>> That specifies the computation P(P)
>>>>>
>>>>> It makes no reference at all to the "relative invocation order" of
>>>>> H with respect to P. It makes no reference to H at all.
>>>>>
>>>>> If its answer doesn't correspond to the behaviour of P(P) which is
>>>>> a halting computation, then its answer is *wrong*.
>>>>
>>>> H(P,P) specifies the invocation order of H(P,P) then P(P).
>>>
>>> H is allegedly a TM which determines whether the computation
>>> described by its *input* halts.
>>>
>>
>> Yes.
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>>
>>> The input to H(P, P) does *not* include H.
>>
>> When P calls H then H becomes input to H.
>
> No, it doesn't. The only inputs to H are (P, P)
>
> That P makes a call to H doesn't make H an input in the above case any
> more than P calling any other function would make that function an input
> to H.
>
> The input to H is a *computation*. Anything inside that computation is
> *part* of that computation, not some distinct input to H
>
Because P calls H that makes H an aspect of the computation of P.
If you can't understand this then that proves that you are totally
unqualified to evaluate my work.
>>> The input specifies P(P). Nothing about H. Nothing about the
>>> invocation order of H(P, P). It is supposed to tell us about the
>>> behaviour of the computation P(P)
>>>
>>> That means the *independent* computation P(P)
>>>
>>
>> When P calls H then H becomes input to H and a dependency is formed.
>>
>> Because of this erroneous pathological self-reference dependency the
>> different execution order of P(P) then H(P,P) compared to H(P,P) then
>> P(P) defines two distinct computations such that opposite behavior of
>> one does not contradict the other.
>>
>>> Not P(P) being invoked inside H.
>>>
>>
>> That H calls P which in turn calls H must be separately accounted for
>> and treated differently.
>>
>>> Not P(P) being simulated by anything.
>>>
>>> The *independent* computation P(P)
>>>
>>
>> There is no independent computation.
>
> Of course there is.
>
> What you insist on referring to by the overly verbose name int main() {
> P(P); } is the independent computation. The fact that P(P) calls other
> functions doesn't make it cease to be an independent computation.
>
>> We either have P(P) dependent on H(P,P)
>> or we have H(P,P) dependent on P(P);
>>
>>> Since you don't even grasp the *question* that a Halt Decider is
>>> supposed to answer, then you probably shouldn't work on them. Maybe
>>> take up macramé or colouring books.
>>>
>>>> If P did not have the pathological self-reference error the
>>>> invocation would not matter. Because P does have the pathological
>>>> self-reference error the invocation order does matter.
>>>
>>> There is no self-reference in P. At least not if it corresponds to
>>> Linz's H_Hat. Until you actually learn what 'self-reference' means,
>>> you probably shouldn't insist on finding it everywhere.
>>
>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>> The Linz conclusion is entirely based on Ĥ applied to its own Turing
>> machine description. (Top paragraph of page 320)
>
> Yes. H_Hat is passed a *description* of a Turing Machine plus an input.
>
> In other words, it is passed a *string*.
>
> There would only be self-reference if H_Hat accepted *itself* as an
> input, which of course is not possible since you can't place a Turing
> Machine on a tape.
>
> X(Description_of_X) is not self-reference.
>
> X(Myself) would be self-reference, and the syntax of most formal
> languages simply don't allow this.
>
>> That you didn't even know this should be sufficient proof that you
>> simply flat out don't know these things as well as you claim.
>>
>> Ĥ applied to ⟨Ĥ⟩ is self-reference.
>
> No, it is not. (H_Hat) is a complete description of a Turing Machine. It
> does not *refer* at all.
>
> Do you understand what "refer" means?
>
>>>
>>>> It is very diffcult to correctly handle incorrect input.
>>>
>>> There's nothing incorrect about (P, P) as an input.
>>>
>>>> The key irrefutable point is that H(P,P) then P(P) is an entirely
>>>> different computation than P(P) then H(P,P) thus the fact that int
>>>
>>> Yes, they are separate computations. But H(P, P) is being asked about
>>> P(P), not about H(P, P).
>>>
>>
>> It is being asked about its input therefore it is being asked about
>> the invocation order of H(P,P) then P() it is not being asked about
>> P(P) than H(P,P). >
>> If we want to ask about the invocation order of P(P) we need another
>> halt decider that is not involved in the pathological self-reference
>> error.
>
> The above is simply an incoherent mess. The input given to H says
> nothing whatsoever about 'invocation orders' H is given two parameters:
> P and P.
>
> If 'invocation orders' makes a difference to how things work and your H
> imposes some 'invocation order' which is different from whatever is
> found in the independent computation P(P), that simply indicates that
> your H is broken. It fails to meet the specifications of a halt decider
> which is *required* to describe the behaviour of the *independent*
> computation described by its input.
>
>> With H1(P,P) we have the same invocation order as int main() { P(P); }.
>
> Until you explain what H1 is, the above conveys no information. All
> you've claimed is that H1 is identical to H yet mysteriously gives a
> different answer from H.
>
>> This would be the same as the original Linz H applied to ⟨Ĥ⟩.
>> Both H1 and H report that their input halts on its input
>
> ???
>
> You've gone to great lengths to justify as correct the fact that your
> H(P, P) claims that its input *doesn't* halt. Now you claim H reports
> that it does halt? You really need to make up your mind.
>
>>> If you want it to tell you about H(P, P) then you need to call H(H,
>>> P, P).
>>>
>>
>> // H2 take two parameters and reports that its input halts.
>> Output("Input_Halts = ", H2((u32)H, (u32)P, (u32)P));
>>
>>>> main() { P(P); } halts does not contradict that H(P,P) correctly
>>>> decides that its input never halts.
>>>
>>> Of course it does because its input, (P, P) *describes* int main() {
>>> P(P); }
>>>
>>
>> // It does not. This one does, and it reports that its input halts.
>> Output("Input_Halts = ", H1((u32)P, (u32)P));
>
> So where is the code for this mysterious H1?
>
>
> 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-31 17:39 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <sgmej0$il4$1@dont-email.me> |
| In reply to | #38621 |
On 2021-08-31 17:29, olcott wrote: > On 8/31/2021 5:40 PM, André G. Isaak wrote: >> On 2021-08-31 15:34, olcott wrote: >>> When P calls H then H becomes input to H. >> >> No, it doesn't. The only inputs to H are (P, P) >> >> That P makes a call to H doesn't make H an input in the above case any >> more than P calling any other function would make that function an >> input to H. >> >> The input to H is a *computation*. Anything inside that computation is >> *part* of that computation, not some distinct input to H >> > > Because P calls H that makes H an aspect of the computation of P. > If you can't understand this then that proves that you are totally > unqualified to evaluate my work. There is an instance of H which is part of P(P). That doesn't make it an *input* to H. If I call the function sum(sqrt(9), 5), nine is *not* an input to this computation. The inputs are 3 and 5. Input == parameter. H takes two parameters. When we call H(P, P) the only parameters are P and P. >> Until you explain what H1 is, the above conveys no information. All >> you've claimed is that H1 is identical to H yet mysteriously gives a >> different answer from H. No response. Why does that not surprise me? 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-31 19:16 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <MtqdnQrAc9vpW7P8nZ2dnUU7-K3NnZ2d@giganews.com> |
| In reply to | #38623 |
On 8/31/2021 6:39 PM, André G. Isaak wrote: > On 2021-08-31 17:29, olcott wrote: >> On 8/31/2021 5:40 PM, André G. Isaak wrote: >>> On 2021-08-31 15:34, olcott wrote: > >>>> When P calls H then H becomes input to H. >>> >>> No, it doesn't. The only inputs to H are (P, P) >>> >>> That P makes a call to H doesn't make H an input in the above case >>> any more than P calling any other function would make that function >>> an input to H. >>> >>> The input to H is a *computation*. Anything inside that computation >>> is *part* of that computation, not some distinct input to H >>> >> >> Because P calls H that makes H an aspect of the computation of P. >> If you can't understand this then that proves that you are totally >> unqualified to evaluate my work. > > There is an instance of H which is part of P(P). That doesn't make it an > *input* to H. > The pathological self-reference error has made the P template an impossible to decide input since 1936. If H was not an aspect of the computation of P it would have never been thought to be an impossible to decide input. > If I call the function sum(sqrt(9), 5), nine is *not* an input to this > computation. The inputs are 3 and 5. > > Input == parameter. H takes two parameters. When we call H(P, P) the > only parameters are P and P. > >>> Until you explain what H1 is, the above conveys no information. All >>> you've claimed is that H1 is identical to H yet mysteriously gives a >>> different answer from H. > > No response. Why does that not surprise me? > > 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-31 20:47 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <x4AXI.9822$7w6.8549@fx42.iad> |
| In reply to | #38624 |
On 8/31/21 8:16 PM, olcott wrote: > On 8/31/2021 6:39 PM, André G. Isaak wrote: >> On 2021-08-31 17:29, olcott wrote: >>> On 8/31/2021 5:40 PM, André G. Isaak wrote: >>>> On 2021-08-31 15:34, olcott wrote: >> >>>>> When P calls H then H becomes input to H. >>>> >>>> No, it doesn't. The only inputs to H are (P, P) >>>> >>>> That P makes a call to H doesn't make H an input in the above case >>>> any more than P calling any other function would make that function >>>> an input to H. >>>> >>>> The input to H is a *computation*. Anything inside that computation >>>> is *part* of that computation, not some distinct input to H >>>> >>> >>> Because P calls H that makes H an aspect of the computation of P. >>> If you can't understand this then that proves that you are totally >>> unqualified to evaluate my work. >> >> There is an instance of H which is part of P(P). That doesn't make it >> an *input* to H. >> > > The pathological self-reference error has made the P template an > impossible to decide input since 1936. If H was not an aspect of the > computation of P it would have never been thought to be an impossible to > decide input. YOU don't seem to understand how this work. The Algorithm of H^ includes as part of (actually most of) its design, a COPY of the Algorithm of the H it is based on. That may be an input to the 'Template' but is part of the machine that the template generates. YOU seem to confuse the template with the machine it generates. Note, the template is ^ not H^, H^ is the name of the machine obtained by applying the ^ template to the machine H. (Which also implies that H has been fixed as a definitive machine). One implication of this is that any arguement that talks about differing Hs needs to also realize it is talking about simeraly differing H^s, a different one for each H. In one sense you can think of this as a form of C++ template, where H^ is really Hat<H> (except that I don't know if C++ actually allow for that construction). > >> If I call the function sum(sqrt(9), 5), nine is *not* an input to this >> computation. The inputs are 3 and 5. >> >> Input == parameter. H takes two parameters. When we call H(P, P) the >> only parameters are P and P. >> >>>> Until you explain what H1 is, the above conveys no information. All >>>> you've claimed is that H1 is identical to H yet mysteriously gives a >>>> different answer from H. >> >> No response. Why does that not surprise me? >> >> André >> >> > >
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-08-31 18:52 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <sgmit2$7kh$1@dont-email.me> |
| In reply to | #38624 |
On 2021-08-31 18:16, olcott wrote:
> On 8/31/2021 6:39 PM, André G. Isaak wrote:
>> On 2021-08-31 17:29, olcott wrote:
>>> On 8/31/2021 5:40 PM, André G. Isaak wrote:
>>>> On 2021-08-31 15:34, olcott wrote:
>>
>>>>> When P calls H then H becomes input to H.
>>>>
>>>> No, it doesn't. The only inputs to H are (P, P)
>>>>
>>>> That P makes a call to H doesn't make H an input in the above case
>>>> any more than P calling any other function would make that function
>>>> an input to H.
>>>>
>>>> The input to H is a *computation*. Anything inside that computation
>>>> is *part* of that computation, not some distinct input to H
>>>>
>>>
>>> Because P calls H that makes H an aspect of the computation of P.
>>> If you can't understand this then that proves that you are totally
>>> unqualified to evaluate my work.
>>
>> There is an instance of H which is part of P(P). That doesn't make it
>> an *input* to H.
>>
>
> The pathological self-reference error has made the P template an
> impossible to decide input since 1936. If H was not an aspect of the
> computation of P it would have never been thought to be an impossible to
> decide input.
Do you not grasp that there is a difference between being part of P and
being an input to H? Those mean entirely different things.
The definition of the halting problem is to come up with a TM which
determines, for any input consisting of a turing machine description and
an input string, whether the COMPUTATION described by that input halts.
In the case of the input (P, P) that means to determine whether P(P)
halts. And yes, that means int main () { H1(P,P); } to use your overly
verbose term.
It does not mean to determine whether H(P, P) halts.
It does not mean to determine how P(P) behaves if it is run under the
scope of some other program such as H.
It does not mean to determine how P(P) behaves in some simulator even
though the result should be the same in an actual, *accurate* simulator
(unlike the one in your H). The fact that two questions might have the
same answer does not make them the same question, and the halting
problem is *not* concerned with simulation.
That's how the problem is *defined*. The definition is completely
unambiguous. Every computer scientist on earth understands what this
question means. (You don't, but that's because you are not a computer
scientist; you're not even a 'software engineer' -- you're just a
piss-poor programmer who doesn't have the slightest grasp of the
fundamentals of computational theory).
So given that P(P) halts, if your H(P, P) answers 'false' it is *not*
correctly answering the question defined by the halting problem.
Any 'decider' which answers a question which doesn't correspond to the
halting problem has *zero* relevance to the halting problem. And the
question you claim to be answering, to the extent that it is even
coherent, is *not* the halting problem.
Find a new hobby.
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-31 21:23 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <CCAXI.10290$z%4.9163@fx37.iad> |
| In reply to | #38624 |
On 8/31/21 8:16 PM, olcott wrote: > On 8/31/2021 6:39 PM, André G. Isaak wrote: >> On 2021-08-31 17:29, olcott wrote: >>> On 8/31/2021 5:40 PM, André G. Isaak wrote: >>>> On 2021-08-31 15:34, olcott wrote: >> >>>>> When P calls H then H becomes input to H. >>>> >>>> No, it doesn't. The only inputs to H are (P, P) >>>> >>>> That P makes a call to H doesn't make H an input in the above case >>>> any more than P calling any other function would make that function >>>> an input to H. >>>> >>>> The input to H is a *computation*. Anything inside that computation >>>> is *part* of that computation, not some distinct input to H >>>> >>> >>> Because P calls H that makes H an aspect of the computation of P. >>> If you can't understand this then that proves that you are totally >>> unqualified to evaluate my work. >> >> There is an instance of H which is part of P(P). That doesn't make it >> an *input* to H. >> > > The pathological self-reference error has made the P template an > impossible to decide input since 1936. If H was not an aspect of the > computation of P it would have never been thought to be an impossible to > decide input. > Thinking a bit, we actually CAN create an example where the decider is a input to the confounding machine (I think this works) Define Hat(D, P) to duplicate its input tape and then put this into a UTM and if the simulated machine halts in the 'Non_Halting' state then it just halts, and if the simulated machine halts in the halting state, it loops forever. let D be the representation of the Halt Decider H and P be the representation of the Hat machine itself. Hat(<H> <Hat>) -> Hat.q0 <H> <Hat> -> Hat.qs <H> <Hat> <H> <Hat> qs then has a UTM which will then simulate H(<Hat> <H> <Hat>) which is asking it to decide on the computation Hat(<H> <Hat>) which is what we started with. So what ever answer H(<Hat> <H> <Hat>) gives, will be wrong as Hat will do the opposite. This formulation makes it explicitly clear what the decider that Hat is built on, as it is now an input.
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2021-08-31 14:17 -0700 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <e455d016-bea0-467c-b195-3d7dcb26f25dn@googlegroups.com> |
| In reply to | #38610 |
On Tuesday, 31 August 2021 at 20:11:39 UTC+1, olcott wrote: > On 8/31/2021 1:40 PM, André G. Isaak wrote: > > > > > It makes no reference at all to the "relative invocation order" of H > > with respect to P. It makes no reference to H at all. > > > > If its answer doesn't correspond to the behaviour of P(P) which is a > > halting computation, then its answer is *wrong*. > H(P,P) specifies the invocation order of H(P,P) then P(P). > > If P did not have the pathological self-reference error the invocation > would not matter. Because P does have the pathological self-reference > error the invocation order does matter. > > It is very diffcult to correctly handle incorrect input. > > The key irrefutable point is that H(P,P) then P(P) is an entirely > different computation than P(P) then H(P,P) > So that's the central point. If H(P,P) from the root is a different computation to H(P,P),called from P, then indeed you can provide a counter-example to the Linz proof.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-31 16:48 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <pbSdnTJ3CNc6PrP8nZ2dnUU7-cnNnZ2d@giganews.com> |
| In reply to | #38612 |
On 8/31/2021 4:17 PM, Malcolm McLean wrote:
> On Tuesday, 31 August 2021 at 20:11:39 UTC+1, olcott wrote:
>> On 8/31/2021 1:40 PM, André G. Isaak wrote:
>>
>>>
>>> It makes no reference at all to the "relative invocation order" of H
>>> with respect to P. It makes no reference to H at all.
>>>
>>> If its answer doesn't correspond to the behaviour of P(P) which is a
>>> halting computation, then its answer is *wrong*.
>> H(P,P) specifies the invocation order of H(P,P) then P(P).
>>
>> If P did not have the pathological self-reference error the invocation
>> would not matter. Because P does have the pathological self-reference
>> error the invocation order does matter.
>>
>> It is very diffcult to correctly handle incorrect input.
>>
>> The key irrefutable point is that H(P,P) then P(P) is an entirely
>> different computation than P(P) then H(P,P)
>>
> So that's the central point. If H(P,P) from the root is a different computation
> to H(P,P),called from P, then indeed you can provide a counter-example to
> the Linz proof.
>
// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
// These are two different computations that can have
// opposite results without contradiction.
int main () { H(P,P); } // invocation order H(P,P) then P(P)
int main () { P(P); } // invocation order P(P) then H(P,P)
H(P,P) from anywhere has exactly the same behavior.
// H1 is an identical copy of H
int main () { H1(P,P); } // reports that its input halts.
The different invocation order of H1 and H is how they can have
identical code and different behavior. Halt deciders can only see the
instructions that they (and their slave instances) simulate. H1 cannot
see any of the instructions that H simulates.
H(P,P); P(P); and H1(P,P); are shown in sections V1,V2,V3 of this paper:
https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-31 19:26 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <vUyXI.10284$z%4.1858@fx37.iad> |
| In reply to | #38615 |
On 8/31/21 5:48 PM, olcott wrote:
> On 8/31/2021 4:17 PM, Malcolm McLean wrote:
>> On Tuesday, 31 August 2021 at 20:11:39 UTC+1, olcott wrote:
>>> On 8/31/2021 1:40 PM, André G. Isaak wrote:
>>>
>>>>
>>>> It makes no reference at all to the "relative invocation order" of H
>>>> with respect to P. It makes no reference to H at all.
>>>>
>>>> If its answer doesn't correspond to the behaviour of P(P) which is a
>>>> halting computation, then its answer is *wrong*.
>>> H(P,P) specifies the invocation order of H(P,P) then P(P).
>>>
>>> If P did not have the pathological self-reference error the invocation
>>> would not matter. Because P does have the pathological self-reference
>>> error the invocation order does matter.
>>>
>>> It is very diffcult to correctly handle incorrect input.
>>>
>>> The key irrefutable point is that H(P,P) then P(P) is an entirely
>>> different computation than P(P) then H(P,P)
>>>
>> So that's the central point. If H(P,P) from the root is a different
>> computation
>> to H(P,P),called from P, then indeed you can provide a counter-example to
>> the Linz proof.
>>
>
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> }
>
> // These are two different computations that can have
> // opposite results without contradiction.
>
> int main () { H(P,P); } // invocation order H(P,P) then P(P)
> int main () { P(P); } // invocation order P(P) then H(P,P)
>
> H(P,P) from anywhere has exactly the same behavior.
>
> // H1 is an identical copy of H
> int main () { H1(P,P); } // reports that its input halts.
>
> The different invocation order of H1 and H is how they can have
> identical code and different behavior. Halt deciders can only see the
> instructions that they (and their slave instances) simulate. H1 cannot
> see any of the instructions that H simulates.
Which just means they are NOT really Computations, since Computation
deliver the same answer for a given input no matter under what
conditions they are invoked.
H isn't really a Computation, thus H isn't eligable to be a Halt Decider.
PERIOD.
END OF YOUR PROOF.
>
> H(P,P); P(P); and H1(P,P); are shown in sections V1,V2,V3 of this paper:
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-31 21:08 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <joAXI.10289$z%4.3418@fx37.iad> |
| In reply to | #38608 |
On 8/31/21 1:55 PM, olcott wrote: > On 8/31/2021 12:00 PM, André G. Isaak wrote: >> On 2021-08-31 10:49, olcott wrote: >>> On 8/31/2021 11:31 AM, André G. Isaak wrote: >>>> On 2021-08-31 10:11, olcott wrote: >>>>> On 8/31/2021 10:07 AM, André G. Isaak wrote: >>>>>> On 2021-08-31 08:24, olcott wrote: >>>>>>> On 8/30/2021 11:45 PM, André G. Isaak wrote: >>>>>> >>>>>>> In computability theory, the halting problem is the >>>>>>> problem of determining, from a description of an >>>>>>> arbitrary computer program and an input, whether the >>>>>>> program will finish running, or continue to run forever. >>>>>>> https://en.wikipedia.org/wiki/Halting_problem >>>>>>> >>>>>>> The halting problem is always about program descriptions >>>>>>> not running programs. This means that it is always about >>>>>>> the input to the halt decider not the direct execution >>>>>>> of the program. >>>>>> >>>>>> This is, of course, errant nonsense. The input to a halt decider >>>>>> is simply data. Data doesn't *have* halting behaviour. Only the >>>>>> actual computation described by that data can have halting >>>>>> behaviour. Your inability to comprehend simple definitions is not >>>>>> the basis for a coherent argument. >>>>>> >>>>>> >>>>>>> The most straight forward way to get the actual behavior of a >>>>>>> program description is to simulate it. >>>>>> >>>>>> No. The most straightforward way, and the ONLY 100% reliable way >>>>>> to get the actual behaviour of a program description is to run the >>>>>> program it describes. >>>>>> >>>>>>>> A pure simulation would have identical halting behaviour as the >>>>>>>> actual computation, but the question isn't about simulations. >>>>>>>> It's about actual computations. It isn't about what happens >>>>>>>> inside some decider; it's about actual computations. >>>>>>>> >>>>>>> >>>>>>> When an "actual computation" has different behavior than the >>>>>>> simulation of the input to the halt decider this proves that the >>>>>>> actual computation is a different computation than the input to >>>>>>> the halt decider thus not relevant to the halting problem. >>>>>> >>>>>> No, it proves that the 'simulation' performed by your halt decider >>>>>> is not an accurate simulation. >>>>>> >>>>>> André >>>>>> >>>>> >>>>> I am posting this again because my post did not show up in Giganews >>>>> >>>>> I think that I finally got it this time: >>>>> >>>>> The difference in the relative invocation order of P(P) to H(P,P) >>>>> accounts for the difference in behavior. >>>>> >>>>> P(P) from main() invokes P(P) then H(P,P). >>>>> >>>>> H(P,P) from main reverses this relative invocation order to H(P,P) >>>>> then P(P). >>>>> >>>>> Changes to the relative invocation order define distinctly >>>>> different computations that can have different behavior without >>>>> contradiction. >>>> >>>> None of this has any bearing on the points I made. I don't care how >>>> you justify the difference in behaviour between an independent P(P) >>>> and one running inside the decider. The job of a halt decider is to >>>> describe the behaviour of the former, not the latter. >>>> >>> >>> In computability theory, the halting problem is the >>> problem of determining, from a description of an >>> arbitrary computer program and an input, whether the >>> program will finish running, or continue to run forever. >>> https://en.wikipedia.org/wiki/Halting_problem >>> >>> The halting problem is always about program descriptions >>> not running programs. This means that it is always about >>> the input to the halt decider not the direct execution >>> of the program. >> >> The input to the halt decider is simply data. Data doesn't halt or not >> halt. Only the thing described by the data can be referred to as >> halting or not halting. And that thing is the actual computation. >> > > The halt decider must base its halting decision on the invocation order > specified by its actual input not some other entirely different > computation. And the input it is asked to decide is on the input <H^> <H^> which represents the top level machine of H^(<H^>) which we know to be Halting. The fact that H makes a mistake and decides to abort this doesn't make that fact untrue. It makes the mistake because it used unsound logic (presuming that copies of itself don't abort the simulations). It is in fact partially BECAUSE it makes that mistake, that H^ is Halting, but that still means it is Halting. The fact that the game is riged so that H can't possibly return a right answer doesn't mean the problem is wrong, just that there can be no machine that can universally solve the problem. > >> The definitions of 'halting' and 'halting problem' are not not >> contentious. The entire CS community agrees on their meanings and the >> halting problem is definitely *not* about how 'inputs' behave. Inputs >> don't *have* behaviour. It's about how the computations represented by >> those inputs behave. >> >> You're treating this definition as if it were about theology or >> poetry: something that's open to interpretation. It isn't. Your >> interpretation is wrong. Plain and simple. >> >>> The job of the halt decider is to correctly decide the behavior of >>> its input in the execution order specified by its input. >>> >>> That another entirely different computation has a different execution >>> order makes this other different computation utterly irrelevant to >>> the actual halting problem. >>> >>> As I have been saying once we know that H(P,P)==0 is correct is >>> logically entailed by its two premises and we know that these two >>> premises are true then nothing in the universe can possibly >>> contradict this. >>> >>>> Think about it. What is the whole point of asking whether a >>>> universal halt decider is possible? It's because the existence of a >>>> such a decider would allow us to solve a wide variety of previously >>>> unsolved problems. >>>> >>>> If we want to know whether some computation, say P(P) halts, we want >>>> to know about the *actual* computation. Why on earth would anyone >>>> even care how it behaves in a particular simulating halt decider? >>>> That behaviour is tied to the specific decider and therefore isn't a >>>> property of the computation we're asking about. So what possible >>>> interest could it be to anyone? >> >> You didn't answer the above. If you actually spend some time thinking >> about it you might realize why your position is entirely ridiculous. >> Why would anyone even think to ask the question which you are >> mistaking for the halting problem? >> >> André >> >> > >
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-31 19:23 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ relative invocation order ] |
| Message-ID | <BRyXI.20385$jm6.15847@fx07.iad> |
| In reply to | #38604 |
On 8/31/21 12:11 PM, olcott wrote: > On 8/31/2021 10:07 AM, André G. Isaak wrote: >> On 2021-08-31 08:24, olcott wrote: >>> On 8/30/2021 11:45 PM, André G. Isaak wrote: >> >>> In computability theory, the halting problem is the >>> problem of determining, from a description of an >>> arbitrary computer program and an input, whether the >>> program will finish running, or continue to run forever. >>> https://en.wikipedia.org/wiki/Halting_problem >>> >>> The halting problem is always about program descriptions >>> not running programs. This means that it is always about >>> the input to the halt decider not the direct execution >>> of the program. >> >> This is, of course, errant nonsense. The input to a halt decider is >> simply data. Data doesn't *have* halting behaviour. Only the actual >> computation described by that data can have halting behaviour. Your >> inability to comprehend simple definitions is not the basis for a >> coherent argument. >> >> >>> The most straight forward way to get the actual behavior of a program >>> description is to simulate it. >> >> No. The most straightforward way, and the ONLY 100% reliable way to >> get the actual behaviour of a program description is to run the >> program it describes. >> >>>> A pure simulation would have identical halting behaviour as the >>>> actual computation, but the question isn't about simulations. It's >>>> about actual computations. It isn't about what happens inside some >>>> decider; it's about actual computations. >>>> >>> >>> When an "actual computation" has different behavior than the >>> simulation of the input to the halt decider this proves that the >>> actual computation is a different computation than the input to the >>> halt decider thus not relevant to the halting problem. >> >> No, it proves that the 'simulation' performed by your halt decider is >> not an accurate simulation. >> >> André >> > > I am posting this again because my post did not show up in Giganews > > I think that I finally got it this time: > > The difference in the relative invocation order of P(P) to H(P,P) > accounts for the difference in behavior. > > P(P) from main() invokes P(P) then H(P,P). > > H(P,P) from main reverses this relative invocation order to H(P,P) then > P(P). > > Changes to the relative invocation order define distinctly different > computations that can have different behavior without contradiction. > > > Yes, H(P,P) is a different computation from P(P), BUT, the right answer for H(P,P) is BY DEFINITION based an the computation for P(P) which, if it IS a Computation will be independent of the conditions under which it is executed. That H thinks otherwise, says either H is wrong, or P(P) isn't a computation, and by its construction, that means that H isn't a computation, and thus not eligible to be a decider. If you want to claim that the simulated machine P(P) given to H is a different Computation than P(P) as a top level machine, basically that is an admission that H isn't a Computation and thus can't really be a decider.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-08-31 06:35 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] |
| Message-ID | <JBnXI.7017$2Q_3.3730@fx35.iad> |
| In reply to | #38587 |
On 8/31/21 12:31 AM, olcott wrote:
> On 8/30/2021 11:19 PM, André G. Isaak wrote:
>> On 2021-08-30 22:00, olcott wrote:
>>> On 8/30/2021 10:35 PM, André G. Isaak wrote:
>>>> On 2021-08-30 21:20, olcott wrote:
>>>>> On 8/30/2021 10:04 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 8/30/2021 9:17 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 8/29/2021 7:00 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 8/29/2021 11:19 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 8/29/2021 10:20 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The fact that the P(P) of main() halts does not
>>>>>>>>>>>>>>> contradict the fact
>>>>>>>>>>>>>>> that H(P,P) of main() correctly decides that its input
>>>>>>>>>>>>>>> never halts
>>>>>>>>>>>>>>> because these are two entirely different computations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What arguments must be passed to H for it to report on the
>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>> computation P(P) "of main()"?
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is already answered in the part that you snipped.
>>>>>>>>>>>>
>>>>>>>>>>>> No it was not. And if I am wrong, show the world that I am
>>>>>>>>>>>> wrong by
>>>>>>>>>>>> writing them again here. It can be no more that two simple C
>>>>>>>>>>>> expressions.
>>>>>>>>>>>
>>>>>>>>>>> It is as I have said an airtight proof, notwithstanding false
>>>>>>>>>>> assumptions to the contrary.
>>>>>>>>>> No answer, as expected.
>>>>>>>>>>
>>>>>>>>>>> You can try to point to an actual error in the proof as its
>>>>>>>>>>> stands and
>>>>>>>>>>> everyone that sufficiently understands the material will see
>>>>>>>>>>> your
>>>>>>>>>>> mistake.
>>>>>>>>>> No answer, as expected.
>>>>>>>>>>
>>>>>>>>>>> It is the case that H(P,P) is a computation that never halts
>>>>>>>>>>> unless
>>>>>>>>>>> its simulation is aborted. It is the case that every
>>>>>>>>>>> computation that
>>>>>>>>>>> never halts unless is simulation is aborted is a non halting
>>>>>>>>>>> computation.
>>>>>>>>>> No answer, as expected.
>>>>>>>>>>
>>>>>>>>>>> There is nothing besides carefully crafted double-talk that goes
>>>>>>>>>>> against this.
>>>>>>>>>> No answer, as expected.
>>>>>>>>>
>>>>>>>>> I will only answer questions that directly pertain to the
>>>>>>>>> points that
>>>>>>>>> I made and will ignore dishonest dodges that attempt to change the
>>>>>>>>> subject away from the points that I made.
>>>>>>>> Dodge, dodge, dodge! All the questions you have been asked pertain
>>>>>>>> directly to the nonsense you post.
>>>>>>>
>>>>>>> I am only discussing that
>>>>>>> H(P,P)==0 is correct is a necessary consequence of its two premises.
>>>>>>
>>>>>> You seem to forget that I agree. H(P,P)==0 is correct given the
>>>>>> criteria you have invented.
>>>>>
>>>>> {H(P,P)==0 is correct} means that the input to H(P,P) is correctly
>>>>> decided as never halting.
>>>>
>>>> H(P, P) is required to answer the question Does P(P) halt"
>>>>
>>>> It is *specifically* being asked about the behaviour of int main() {
>>>> P(P); }
>>>>
>>>> It is *not* being asked about the behaviour of P(P) "under the
>>>> dominion of a halt decider" (whatever that may mean) nor about any
>>>> computation other than int main() { P(P); }. This follows directly
>>>> from how the halting problem is *defined*.
>>>
>>> In computability theory, the halting problem is the
>>> problem of determining, from a description of an
>>> arbitrary computer program and an input, whether the
>>> program will finish running, or continue to run forever.
>>> https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> No that is not true. The halting problem is always about program
>>> descriptions not running programs. This means that it is always about
>>> the input to the halt decider not the direct execution of the program.
>>
>> The *input* to the decider is a program description. But the question
>> the halt decider is expected to answer is about the *actual* program
>> which that description describes.
>>
>
> In other words whether or not the the pure simulation of this
> description halts on its input.
Yes, you can use a PURE simulation, which is a simulation that
ACCURATELY recreates ALL of the behavior of the program described, which
means it NEVER stops simulating until the program actually halts.
H is NOT a PURE Simulator.
Being a Pure Simulator is sort of like immortality, you are not immortal
if you just live until you die, to be immortal you need to live forever
and never die. If you ar just acting like an immortal until you die, you
were never immortal, just deceived, and possible very surprised when
then end comes.
Same with a pure simulation. Acting like one and then stopping, doesn't
make you one, it just shows you never were.
>
>>> If the input to the halt decider never halts unless the halt decider
>>> aborts its simulation of this input then its input never halts.
>>
>> If P(P) halts, but the "simulation of P(P)" does not, then either your
>> simulator is broken or whatever is being simulated by the decider
>> *isn't* the the program which which was actually described by its
>> input. It is therefore answering about the *wrong* program.
>>
>> André
>>
>
> Like I said H(P,P)==0 is correct as a logical consequence of its two
> premises and its two premises are true. There is no escape from this.
>
UNSOUND. POOP.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-08-31 14:55 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] |
| Message-ID | <877dg14t36.fsf@bsb.me.uk> |
| In reply to | #38582 |
olcott <NoOne@NoWhere.com> writes:
> On 8/30/2021 10:04 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 8/30/2021 9:17 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 8/29/2021 7:00 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 8/29/2021 11:19 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 8/29/2021 10:20 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> The fact that the P(P) of main() halts does not contradict the fact
>>>>>>>>>>> that H(P,P) of main() correctly decides that its input never halts
>>>>>>>>>>> because these are two entirely different computations.
>>>>>>>>>>
>>>>>>>>>> What arguments must be passed to H for it to report on the halting
>>>>>>>>>> computation P(P) "of main()"?
>>>>>>>>>
>>>>>>>>> That is already answered in the part that you snipped.
>>>>>>>>
>>>>>>>> No it was not. And if I am wrong, show the world that I am wrong by
>>>>>>>> writing them again here. It can be no more that two simple C
>>>>>>>> expressions.
>>>>>>>
>>>>>>> It is as I have said an airtight proof, notwithstanding false
>>>>>>> assumptions to the contrary.
>>>>>> No answer, as expected.
>>>>>>
>>>>>>> You can try to point to an actual error in the proof as its stands and
>>>>>>> everyone that sufficiently understands the material will see your
>>>>>>> mistake.
>>>>>> No answer, as expected.
>>>>>>
>>>>>>> It is the case that H(P,P) is a computation that never halts unless
>>>>>>> its simulation is aborted. It is the case that every computation that
>>>>>>> never halts unless is simulation is aborted is a non halting
>>>>>>> computation.
>>>>>> No answer, as expected.
>>>>>>
>>>>>>> There is nothing besides carefully crafted double-talk that goes
>>>>>>> against this.
>>>>>> No answer, as expected.
>>>>>
>>>>> I will only answer questions that directly pertain to the points that
>>>>> I made and will ignore dishonest dodges that attempt to change the
>>>>> subject away from the points that I made.
>>>> Dodge, dodge, dodge! All the questions you have been asked pertain
>>>> directly to the nonsense you post.
>>>
>>> I am only discussing that
>>> H(P,P)==0 is correct is a necessary consequence of its two premises.
>> You seem to forget that I agree. H(P,P)==0 is correct given the
>> criteria you have invented.
>
> {H(P,P)==0 is correct} means that the input to H(P,P) is correctly
> decided as never halting.
No, the "input to H(P,P)" is correctly decided as never PO-halting, a
fact no one cares about. You've been very clear about this new and
profoundly silly definition. You've stated it in all sort of different
ways, and it's just as silly in every version.
People care about halting, and the arguments to H in the call H(P,P)
/should/ represent the halting computation P(P) but you tell us they
don't. And for Turing machines the string <H^> <H^> represents the
halting computation of H^ with <H^> on the tape. You will have not
admitted that error.
> When X is logically necessitated by Y and Z and Y and Z are true then
> we know that X is true and nothing else in the universe can contradict
> this.
You have real trouble dealing with agreement, don't you? I am 100%
prepared to agree that H(P,P) == 0 is correctly reporting something that
you've decided to call halting. It does not, however, report the fact
that P(P) halts. Hijacking words is a silly game.
According to you, there are no arguments that can be passed to H that
represent the halting computation P(P), which just confirms what
everyone but you already knows: every algorithm fails to correctly
report the halting of some computation. For your H it's P(P) for the
rather novel reason that H can't even be asked for an answer!
If you had any desire to be honest, you'd now (a) stop calling what
H(P,P) reports as "halting"; (b) stop showing
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-08-31 09:28 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] |
| Message-ID | <i_qdnd29nu4HobP8nZ2dnUU7-TudnZ2d@giganews.com> |
| In reply to | #38595 |
On 8/31/2021 8:55 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 8/30/2021 10:04 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 8/30/2021 9:17 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 8/29/2021 7:00 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 8/29/2021 11:19 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 8/29/2021 10:20 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> The fact that the P(P) of main() halts does not contradict the fact
>>>>>>>>>>>> that H(P,P) of main() correctly decides that its input never halts
>>>>>>>>>>>> because these are two entirely different computations.
>>>>>>>>>>>
>>>>>>>>>>> What arguments must be passed to H for it to report on the halting
>>>>>>>>>>> computation P(P) "of main()"?
>>>>>>>>>>
>>>>>>>>>> That is already answered in the part that you snipped.
>>>>>>>>>
>>>>>>>>> No it was not. And if I am wrong, show the world that I am wrong by
>>>>>>>>> writing them again here. It can be no more that two simple C
>>>>>>>>> expressions.
>>>>>>>>
>>>>>>>> It is as I have said an airtight proof, notwithstanding false
>>>>>>>> assumptions to the contrary.
>>>>>>> No answer, as expected.
>>>>>>>
>>>>>>>> You can try to point to an actual error in the proof as its stands and
>>>>>>>> everyone that sufficiently understands the material will see your
>>>>>>>> mistake.
>>>>>>> No answer, as expected.
>>>>>>>
>>>>>>>> It is the case that H(P,P) is a computation that never halts unless
>>>>>>>> its simulation is aborted. It is the case that every computation that
>>>>>>>> never halts unless is simulation is aborted is a non halting
>>>>>>>> computation.
>>>>>>> No answer, as expected.
>>>>>>>
>>>>>>>> There is nothing besides carefully crafted double-talk that goes
>>>>>>>> against this.
>>>>>>> No answer, as expected.
>>>>>>
>>>>>> I will only answer questions that directly pertain to the points that
>>>>>> I made and will ignore dishonest dodges that attempt to change the
>>>>>> subject away from the points that I made.
>>>>> Dodge, dodge, dodge! All the questions you have been asked pertain
>>>>> directly to the nonsense you post.
>>>>
>>>> I am only discussing that
>>>> H(P,P)==0 is correct is a necessary consequence of its two premises.
>>> You seem to forget that I agree. H(P,P)==0 is correct given the
>>> criteria you have invented.
>>
>> {H(P,P)==0 is correct} means that the input to H(P,P) is correctly
>> decided as never halting.
>
> No, the "input to H(P,P)" is correctly decided as never PO-halting, a
> fact no one cares about. You've been very clear about this new and
> profoundly silly definition. You've stated it in all sort of different
> ways, and it's just as silly in every version.
>
> People care about halting, and the arguments to H in the call H(P,P)
> /should/ represent the halting computation P(P) but you tell us they
> don't. And for Turing machines the string <H^> <H^> represents the
> halting computation of H^ with <H^> on the tape. You will have not
> admitted that error.
>
>> When X is logically necessitated by Y and Z and Y and Z are true then
>> we know that X is true and nothing else in the universe can contradict
>> this.
>
> You have real trouble dealing with agreement, don't you? I am 100%
> prepared to agree that H(P,P) == 0 is correctly reporting something that
> you've decided to call halting. It does not, however, report the fact
> that P(P) halts. Hijacking words is a silly game.
>
> According to you, there are no arguments that can be passed to H that
> represent the halting computation P(P), which just confirms what
> everyone but you already knows: every algorithm fails to correctly
> report the halting of some computation. For your H it's P(P) for the
> rather novel reason that H can't even be asked for an answer!
>
> If you had any desire to be honest, you'd now (a) stop calling what
> H(P,P) reports as "halting"; (b) stop showing
>
In computability theory, the halting problem is the
problem of determining, from a description of an
arbitrary computer program and an input, whether the
program will finish running, or continue to run forever.
https://en.wikipedia.org/wiki/Halting_problem
The halting problem is always about program descriptions
not running programs. This means that it is always about
the input to the halt decider not the direct execution
of the program.
The most straight forward way to get the actual behavior of a program
description is to simulate it.
The actual computation must be at the same point in the execution trace
as the input to the halt decider. The only way to do this is to simulate
the input to the halt decider. Running the program at some other point
in the execution trace does not count because it defines a different
computation than the one under investigation.
int main() { P(P); } halts because of what H(P,P) does later on.
int main() { H(P,P); } halts because it aborts its simulation.
This proves that the above pair are different computations that can have
opposite behavior without contradiction.
In the above two computations the relative order of P(P) to H(P,P) is
reversed thus changing their relative placement in the execution trace
which changes their behavior.
--
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-31 20:59 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ air tight proof ] |
| Message-ID | <AfAXI.32968$o45.15613@fx46.iad> |
| In reply to | #38599 |
On 8/31/21 10:28 AM, olcott wrote:
> On 8/31/2021 8:55 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 8/30/2021 10:04 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 8/30/2021 9:17 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 8/29/2021 7:00 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 8/29/2021 11:19 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 8/29/2021 10:20 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> The fact that the P(P) of main() halts does not contradict
>>>>>>>>>>>>> the fact
>>>>>>>>>>>>> that H(P,P) of main() correctly decides that its input
>>>>>>>>>>>>> never halts
>>>>>>>>>>>>> because these are two entirely different computations.
>>>>>>>>>>>>
>>>>>>>>>>>> What arguments must be passed to H for it to report on the
>>>>>>>>>>>> halting
>>>>>>>>>>>> computation P(P) "of main()"?
>>>>>>>>>>>
>>>>>>>>>>> That is already answered in the part that you snipped.
>>>>>>>>>>
>>>>>>>>>> No it was not. And if I am wrong, show the world that I am
>>>>>>>>>> wrong by
>>>>>>>>>> writing them again here. It can be no more that two simple C
>>>>>>>>>> expressions.
>>>>>>>>>
>>>>>>>>> It is as I have said an airtight proof, notwithstanding false
>>>>>>>>> assumptions to the contrary.
>>>>>>>> No answer, as expected.
>>>>>>>>
>>>>>>>>> You can try to point to an actual error in the proof as its
>>>>>>>>> stands and
>>>>>>>>> everyone that sufficiently understands the material will see your
>>>>>>>>> mistake.
>>>>>>>> No answer, as expected.
>>>>>>>>
>>>>>>>>> It is the case that H(P,P) is a computation that never halts
>>>>>>>>> unless
>>>>>>>>> its simulation is aborted. It is the case that every
>>>>>>>>> computation that
>>>>>>>>> never halts unless is simulation is aborted is a non halting
>>>>>>>>> computation.
>>>>>>>> No answer, as expected.
>>>>>>>>
>>>>>>>>> There is nothing besides carefully crafted double-talk that goes
>>>>>>>>> against this.
>>>>>>>> No answer, as expected.
>>>>>>>
>>>>>>> I will only answer questions that directly pertain to the points
>>>>>>> that
>>>>>>> I made and will ignore dishonest dodges that attempt to change the
>>>>>>> subject away from the points that I made.
>>>>>> Dodge, dodge, dodge! All the questions you have been asked pertain
>>>>>> directly to the nonsense you post.
>>>>>
>>>>> I am only discussing that
>>>>> H(P,P)==0 is correct is a necessary consequence of its two premises.
>>>> You seem to forget that I agree. H(P,P)==0 is correct given the
>>>> criteria you have invented.
>>>
>>> {H(P,P)==0 is correct} means that the input to H(P,P) is correctly
>>> decided as never halting.
>>
>> No, the "input to H(P,P)" is correctly decided as never PO-halting, a
>> fact no one cares about. You've been very clear about this new and
>> profoundly silly definition. You've stated it in all sort of different
>> ways, and it's just as silly in every version.
>>
>> People care about halting, and the arguments to H in the call H(P,P)
>> /should/ represent the halting computation P(P) but you tell us they
>> don't. And for Turing machines the string <H^> <H^> represents the
>> halting computation of H^ with <H^> on the tape. You will have not
>> admitted that error.
>>
>>> When X is logically necessitated by Y and Z and Y and Z are true then
>>> we know that X is true and nothing else in the universe can contradict
>>> this.
>>
>> You have real trouble dealing with agreement, don't you? I am 100%
>> prepared to agree that H(P,P) == 0 is correctly reporting something that
>> you've decided to call halting. It does not, however, report the fact
>> that P(P) halts. Hijacking words is a silly game.
>>
>> According to you, there are no arguments that can be passed to H that
>> represent the halting computation P(P), which just confirms what
>> everyone but you already knows: every algorithm fails to correctly
>> report the halting of some computation. For your H it's P(P) for the
>> rather novel reason that H can't even be asked for an answer!
>>
>> If you had any desire to be honest, you'd now (a) stop calling what
>> H(P,P) reports as "halting"; (b) stop showing
>>
>
> In computability theory, the halting problem is the
> problem of determining, from a description of an
> arbitrary computer program and an input, whether the
> program will finish running, or continue to run forever.
> https://en.wikipedia.org/wiki/Halting_problem
>
> The halting problem is always about program descriptions
> not running programs. This means that it is always about
> the input to the halt decider not the direct execution
> of the program.
>
Please read that again!
What is the question?
... whether the program will finish running, or continue to run forever.
So what is important, the ACTUAL program, which was specified by a
description.
> The most straight forward way to get the actual behavior of a program
> description is to simulate it.
Only to the degree that simulating actually represents the behavior of
the ACTUAL machine.
>
> The actual computation must be at the same point in the execution trace
> as the input to the halt decider. The only way to do this is to simulate
> the input to the halt decider. Running the program at some other point
> in the execution trace does not count because it defines a different
> computation than the one under investigation.
Nope. A Computation ALWAYS produces the same result from the same input.
PERIOD. Otherwise it is not a Computation.
>
> int main() { P(P); } halts because of what H(P,P) does later on.
> int main() { H(P,P); } halts because it aborts its simulation.
>
> This proves that the above pair are different computations that can have
> opposite behavior without contradiction.
No one argues this. What we do argue is your claim that the simulated
P(P) is different from the actual Machine P(P).
>
> In the above two computations the relative order of P(P) to H(P,P) is
> reversed thus changing their relative placement in the execution trace
> which changes their behavior.
>
I will give you a simple challenge.
Look at the trace of the running of P(P) as called from main.
Also look at the trace of the running of P(P) as a simulation inside H.
Other than the trace of the simulation stopping early, do they differ?
If so, why?
(f not, how can you argue that the second trace must differ from the
first if the simulation was allowed to continue by changing just the top
level H that was doing the simulation (and not the copy inside the
simulation, as THAT would change the machine).
If H does accurately simulate its input (to the point it aborts the
simulation) then other simulators (including other halt deciders and
even a real pure simulator like a UTM) should produce the same results
for what the do simulate, and if they go farther, what that machine
would have done had the simulator run longer.
Since UTM(H^,H^) will do the same thing as H^(H^) which is Halt, that is
what the simulated machine must do (this assumes we are talking abot the
normal H we talk about the returns H(H^,H^) == 0, not the other one that
never returns).
[toc] | [prev] | [next] | [standalone]
Page 3 of 37 — ← Prev page 1 2 [3] 4 5 … 37 Next page →
Back to top | Article view | comp.theory
csiph-web