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 16 of 37 — ← Prev page 1 … 14 15 [16] 17 18 … 37 Next page →
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-03 12:49 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <4msYI.10320$%Z2.9163@fx06.iad> |
| In reply to | #38725 |
On 9/3/21 10:05 AM, olcott wrote:
> On 9/2/2021 11:59 PM, André G. Isaak wrote:
>> On 2021-09-02 22:09, olcott wrote:
>>> On 9/2/2021 10:52 PM, Richard Damon wrote:
>>>> On 9/2/21 11:18 PM, olcott wrote:
>>
>>>>> Any input that never halts unless its simulation is aborted is an
>>>>> input
>>>>> that never halts.
>>>>>
>>>>
>>>> Bad Terminology. Inputs themselves don't halt. They only represent
>>>> computations that might be halting or not.
>>>>
>>>
>>> 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
>>>
>>> To bypass the pathology of pathological inputs:
>>> In computability theory, the halting problem is the
>>> problem of determining, from a description of an arbitrary
>>> computer program and an input,
>>>
>>> whether the simulation of this input must be aborted to
>>> prevent it from running forever.
>>>
>>> The above criteria is valid on the basis of the known equivalence
>>> between the direct execution of a computation and its simulation by a
>>> UTM. The same criteria universally works on all inputs.
>>
>> But the direct execution of P(P) *does* halt. So if there is an
>> equivalence between direct execution and simulation by a UTM, then the
>> simulation by a UTM must also halt.
>>
>> André
>>
>
> The direct execution of P has a dependency on the H(P,P) that it calls.
> int main(){ P(P); } only halts because its call to H(P,P) returns 0. No
> instance of H(P,P) has any dependency on the return value of another
> function.
>
> This makes int main(){ P(P); } a computationally distinct different
> computation than H(P,P) that has no such dependency.
>
> You can dance all around this yet there exists no correct rebuttal in
> the universe that shows that these computations are equivalent or that
> computations that are not equivalent must have equivalent behavior.
But that dance you make doesn't get around the DEFINITION of what H is
supposed to answer.
H(<P>,<I>) is required, if it is to be correct, to give an answer that
matches the bahavior of P(I). PERIOD. DEFINITION.
Key point, the simulation by H of <P> <I> doesn't change the actual
behavior of P(I). If H aborts the simulation of <P> <I> before that
simulation reaches it final halting state (if it has one) doesn't make
the machine non-halting, or the input represent a non-halting computation.
>
> 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
>
> To bypass the pathology of pathological inputs:
I.E. Because I don't like the results of the above definition, I will
create my own POOP based on a different criteria. You don't get to
change the definitions. PERIOD.
> In computability theory, the halting problem is the
> problem of determining, from a description of an arbitrary
> computer program and an input,
>
> whether the simulation of this program must be aborted to
> prevent it from running forever.
The correctness of this sentence hangs on the meaning that have been
assigned to the words.
>
> The above criteria is valid on the basis of the known equivalence
> between the direct execution of a computation and its simulation
> by a UTM. The same criteria universally works on all inputs allowing
> their halting status to be correctly decided.
>
Right, if it means that IF and only IF UTM(<P>, <I>) is non-halting,
then H(<P>, <I>) should return the non-halting answer and if
UTM(<P>,<I>) is Halting then H(<P>,<I>) should return the halting answer.
If you means something different, then the criteria is FALSE.
By the RIGHT interpretation, we KNOW that UTM(<H^>, <H^>) will halt if H
says H(<H^>,<H^>) is non-halting, so the non-halting answer of H is
wrong. PERIDD.
You make the mistake of assuming a partial simulator is a UTM. It isn't.
Just as you are not immortal just because you are still currently living.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 15:11 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <bZCdnU4Qt_PDHK_8nZ2dnUU7-X_NnZ2d@giganews.com> |
| In reply to | #38752 |
On 9/3/2021 11:49 AM, Richard Damon wrote:
> On 9/3/21 10:05 AM, olcott wrote:
>> On 9/2/2021 11:59 PM, André G. Isaak wrote:
>>> On 2021-09-02 22:09, olcott wrote:
>>>> On 9/2/2021 10:52 PM, Richard Damon wrote:
>>>>> On 9/2/21 11:18 PM, olcott wrote:
>>>
>>>>>> Any input that never halts unless its simulation is aborted is an
>>>>>> input
>>>>>> that never halts.
>>>>>>
>>>>>
>>>>> Bad Terminology. Inputs themselves don't halt. They only represent
>>>>> computations that might be halting or not.
>>>>>
>>>>
>>>> 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
>>>>
>>>> To bypass the pathology of pathological inputs:
>>>> In computability theory, the halting problem is the
>>>> problem of determining, from a description of an arbitrary
>>>> computer program and an input,
>>>>
>>>> whether the simulation of this input must be aborted to
>>>> prevent it from running forever.
>>>>
>>>> The above criteria is valid on the basis of the known equivalence
>>>> between the direct execution of a computation and its simulation by a
>>>> UTM. The same criteria universally works on all inputs.
>>>
>>> But the direct execution of P(P) *does* halt. So if there is an
>>> equivalence between direct execution and simulation by a UTM, then the
>>> simulation by a UTM must also halt.
>>>
>>> André
>>>
>>
>> The direct execution of P has a dependency on the H(P,P) that it calls.
>> int main(){ P(P); } only halts because its call to H(P,P) returns 0. No
>> instance of H(P,P) has any dependency on the return value of another
>> function.
>>
>> This makes int main(){ P(P); } a computationally distinct different
>> computation than H(P,P) that has no such dependency.
>>
>> You can dance all around this yet there exists no correct rebuttal in
>> the universe that shows that these computations are equivalent or that
>> computations that are not equivalent must have equivalent behavior.
>
> But that dance you make doesn't get around the DEFINITION of what H is
> supposed to answer.
>
H(P,P) is supposed to answer whether or not its input would halt on its
input.
This part seems to be beyond your capacity to understand:
If H is required to abort its simulation of its input to prevent the
simulation from running forever then this means that the input specifies
infinite execution.
It took me 17 years and 12-16 thousand hours to come up with that. That
is the crux of the essence of my whole solution. That same simple rule
correctly decides the halt status of all inputs pathological or not.
> H(<P>,<I>) is required, if it is to be correct, to give an answer that
> matches the bahavior of P(I). PERIOD. DEFINITION.
>
> Key point, the simulation by H of <P> <I> doesn't change the actual
> behavior of P(I). If H aborts the simulation of <P> <I> before that
> simulation reaches it final halting state (if it has one) doesn't make
> the machine non-halting, or the input represent a non-halting computation.
>
>
>>
>> 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
>>
>> To bypass the pathology of pathological inputs:
>
> I.E. Because I don't like the results of the above definition, I will
> create my own POOP based on a different criteria. You don't get to
> change the definitions. PERIOD.
>
>> In computability theory, the halting problem is the
>> problem of determining, from a description of an arbitrary
>> computer program and an input,
>>
>> whether the simulation of this program must be aborted to
>> prevent it from running forever.
>
> The correctness of this sentence hangs on the meaning that have been
> assigned to the words.
>
>>
>> The above criteria is valid on the basis of the known equivalence
>> between the direct execution of a computation and its simulation
>> by a UTM. The same criteria universally works on all inputs allowing
>> their halting status to be correctly decided.
>>
>
> Right, if it means that IF and only IF UTM(<P>, <I>) is non-halting,
> then H(<P>, <I>) should return the non-halting answer and if
> UTM(<P>,<I>) is Halting then H(<P>,<I>) should return the halting answer.
>
> If you means something different, then the criteria is FALSE.
>
> By the RIGHT interpretation, we KNOW that UTM(<H^>, <H^>) will halt if H
> says H(<H^>,<H^>) is non-halting, so the non-halting answer of H is
> wrong. PERIDD.
>
>
> You make the mistake of assuming a partial simulator is a UTM. It isn't.
> Just as you are not immortal just because you are still currently living.
>
--
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-09-03 16:58 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <%%vYI.21529$F26.12339@fx44.iad> |
| In reply to | #38757 |
On 9/3/21 4:11 PM, olcott wrote:
> On 9/3/2021 11:49 AM, Richard Damon wrote:
>> On 9/3/21 10:05 AM, olcott wrote:
>>> On 9/2/2021 11:59 PM, André G. Isaak wrote:
>>>> On 2021-09-02 22:09, olcott wrote:
>>>>> On 9/2/2021 10:52 PM, Richard Damon wrote:
>>>>>> On 9/2/21 11:18 PM, olcott wrote:
>>>>
>>>>>>> Any input that never halts unless its simulation is aborted is an
>>>>>>> input
>>>>>>> that never halts.
>>>>>>>
>>>>>>
>>>>>> Bad Terminology. Inputs themselves don't halt. They only represent
>>>>>> computations that might be halting or not.
>>>>>>
>>>>>
>>>>> 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
>>>>>
>>>>> To bypass the pathology of pathological inputs:
>>>>> In computability theory, the halting problem is the
>>>>> problem of determining, from a description of an arbitrary
>>>>> computer program and an input,
>>>>>
>>>>> whether the simulation of this input must be aborted to
>>>>> prevent it from running forever.
>>>>>
>>>>> The above criteria is valid on the basis of the known equivalence
>>>>> between the direct execution of a computation and its simulation by a
>>>>> UTM. The same criteria universally works on all inputs.
>>>>
>>>> But the direct execution of P(P) *does* halt. So if there is an
>>>> equivalence between direct execution and simulation by a UTM, then the
>>>> simulation by a UTM must also halt.
>>>>
>>>> André
>>>>
>>>
>>> The direct execution of P has a dependency on the H(P,P) that it calls.
>>> int main(){ P(P); } only halts because its call to H(P,P) returns 0. No
>>> instance of H(P,P) has any dependency on the return value of another
>>> function.
>>>
>>> This makes int main(){ P(P); } a computationally distinct different
>>> computation than H(P,P) that has no such dependency.
>>>
>>> You can dance all around this yet there exists no correct rebuttal in
>>> the universe that shows that these computations are equivalent or that
>>> computations that are not equivalent must have equivalent behavior.
>>
>> But that dance you make doesn't get around the DEFINITION of what H is
>> supposed to answer.
>>
>
> H(P,P) is supposed to answer whether or not its input would halt on its
> input.
>
> This part seems to be beyond your capacity to understand:
No, it seemt the question that is actually being asked is beyond YOUR
understanding, even though you can parrot the words.
A Halt Decider is supposed to answer whether or not the MACHINE + INPUT
REPRESENTED by its input would halt or not when run given that input.
'Inputs' don't do anything, only the actual machines they represent.
>
> If H is required to abort its simulation of its input to prevent the
> simulation from running forever then this means that the input specifies
> infinite execution.
Yes, H is in a tough position, an actually untenable position, which is
part of the reason the task can shown to be impossible. Your problem is
you keep on trying to add in an assumption that it can be done.
If H uses some fixed amount of simulation to try to decide, then it sees
a copy of itself that has done less work then itself, that to predict
what it will do, it needs to run it to its decision point, but as it
gives itself more time, that other copy will also take more time, so it
will never see it making the decision. It fails because it can't find an
x such that x > x+1.
Even if H uses some adaptive process, where if it sees that it is
deciding on a copy of itself, it increase how long it waits, it runs
into the issue that THAT H will also see that same thing and increase
its time too, causing the outer H to not wait long enough, or it needs
to detect this adjustment and adjust its self too. The problem here is
that H won't ever actually get to the point to be able to make the
decision, so H fails to be a decider.
This basically just proves that just trying to simulate will lead to
cases where the decider can't decider and just fails.
Ultimately, H needs to have some logic to break the otherwise infinite
simulation loop, and your aborting criteria is a step in the right
dirction, it makes the error of assuming that the inner simulators won't
abort the simulation, while we KNOW that for H to be able to answer, it
WILL abort the simulation, so the logic used must take that into
account, which is a much harder problem (actually impossible).
It has been previously shown that if you can detect this recusive case
(which actually isn't as easy as you think when you try to implement it
fully following the rules) then you can build an H that handles many of
the recusive (but non-contrary) situations and get the right answer, but
for the case of H^, the machine just gets into a state where it knows it
is going to be wrong, but there is no allowable answer it can give in
that case and be right, so it needs to be wrong, it just gets a choice
in how it will be wrong.
>
> It took me 17 years and 12-16 thousand hours to come up with that. That
> is the crux of the essence of my whole solution. That same simple rule
> correctly decides the halt status of all inputs pathological or not.
And you still don't have the right handle on the problem.
You rule doesn't match the actual definition of Halting (at least the
way you apply it), so you get the wrong answer.
>
>> H(<P>,<I>) is required, if it is to be correct, to give an answer that
>> matches the bahavior of P(I). PERIOD. DEFINITION.
>>
>> Key point, the simulation by H of <P> <I> doesn't change the actual
>> behavior of P(I). If H aborts the simulation of <P> <I> before that
>> simulation reaches it final halting state (if it has one) doesn't make
>> the machine non-halting, or the input represent a non-halting
>> computation.
>>
>>
>>>
>>> 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
>>>
>>> To bypass the pathology of pathological inputs:
>>
>> I.E. Because I don't like the results of the above definition, I will
>> create my own POOP based on a different criteria. You don't get to
>> change the definitions. PERIOD.
>>
>>> In computability theory, the halting problem is the
>>> problem of determining, from a description of an arbitrary
>>> computer program and an input,
>>>
>>> whether the simulation of this program must be aborted to
>>> prevent it from running forever.
>>
>> The correctness of this sentence hangs on the meaning that have been
>> assigned to the words.
>>
>>>
>>> The above criteria is valid on the basis of the known equivalence
>>> between the direct execution of a computation and its simulation
>>> by a UTM. The same criteria universally works on all inputs allowing
>>> their halting status to be correctly decided.
>>>
>>
>> Right, if it means that IF and only IF UTM(<P>, <I>) is non-halting,
>> then H(<P>, <I>) should return the non-halting answer and if
>> UTM(<P>,<I>) is Halting then H(<P>,<I>) should return the halting answer.
>>
>> If you means something different, then the criteria is FALSE.
>>
>> By the RIGHT interpretation, we KNOW that UTM(<H^>, <H^>) will halt if H
>> says H(<H^>,<H^>) is non-halting, so the non-halting answer of H is
>> wrong. PERIDD.
>>
>>
>> You make the mistake of assuming a partial simulator is a UTM. It isn't.
>> Just as you are not immortal just because you are still currently living.
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 16:23 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <8NydndgJ5f_ND6_8nZ2dnUU7-e9h4p2d@giganews.com> |
| In reply to | #38765 |
On 9/3/2021 3:58 PM, Richard Damon wrote:
> On 9/3/21 4:11 PM, olcott wrote:
>> On 9/3/2021 11:49 AM, Richard Damon wrote:
>>> On 9/3/21 10:05 AM, olcott wrote:
>>>> On 9/2/2021 11:59 PM, André G. Isaak wrote:
>>>>> On 2021-09-02 22:09, olcott wrote:
>>>>>> On 9/2/2021 10:52 PM, Richard Damon wrote:
>>>>>>> On 9/2/21 11:18 PM, olcott wrote:
>>>>>
>>>>>>>> Any input that never halts unless its simulation is aborted is an
>>>>>>>> input
>>>>>>>> that never halts.
>>>>>>>>
>>>>>>>
>>>>>>> Bad Terminology. Inputs themselves don't halt. They only represent
>>>>>>> computations that might be halting or not.
>>>>>>>
>>>>>>
>>>>>> 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
>>>>>>
>>>>>> To bypass the pathology of pathological inputs:
>>>>>> In computability theory, the halting problem is the
>>>>>> problem of determining, from a description of an arbitrary
>>>>>> computer program and an input,
>>>>>>
>>>>>> whether the simulation of this input must be aborted to
>>>>>> prevent it from running forever.
>>>>>>
>>>>>> The above criteria is valid on the basis of the known equivalence
>>>>>> between the direct execution of a computation and its simulation by a
>>>>>> UTM. The same criteria universally works on all inputs.
>>>>>
>>>>> But the direct execution of P(P) *does* halt. So if there is an
>>>>> equivalence between direct execution and simulation by a UTM, then the
>>>>> simulation by a UTM must also halt.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> The direct execution of P has a dependency on the H(P,P) that it calls.
>>>> int main(){ P(P); } only halts because its call to H(P,P) returns 0. No
>>>> instance of H(P,P) has any dependency on the return value of another
>>>> function.
>>>>
>>>> This makes int main(){ P(P); } a computationally distinct different
>>>> computation than H(P,P) that has no such dependency.
>>>>
>>>> You can dance all around this yet there exists no correct rebuttal in
>>>> the universe that shows that these computations are equivalent or that
>>>> computations that are not equivalent must have equivalent behavior.
>>>
>>> But that dance you make doesn't get around the DEFINITION of what H is
>>> supposed to answer.
>>>
>>
>> H(P,P) is supposed to answer whether or not its input would halt on its
>> input.
>>
>> This part seems to be beyond your capacity to understand:
>
> No, it seemt the question that is actually being asked is beyond YOUR
> understanding, even though you can parrot the words.
>
> A Halt Decider is supposed to answer whether or not the MACHINE + INPUT
> REPRESENTED by its input would halt or not when run given that input.
>
> 'Inputs' don't do anything, only the actual machines they represent.
>
>>
>> If H is required to abort its simulation of its input to prevent the
>> simulation from running forever then this means that the input specifies
>> infinite execution.
>
> Yes, H is in a tough position, an actually untenable position, which is
> part of the reason the task can shown to be impossible. Your problem is
> you keep on trying to add in an assumption that it can be done.
>
> If H uses some fixed amount of simulation to try to decide, then it sees
> a copy of itself that has done less work then itself, that to predict
> what it will do, it needs to run it to its decision point, but as it
> gives itself more time, that other copy will also take more time, so it
> will never see it making the decision. It fails because it can't find an
> x such that x > x+1.
>
That is simply not the way that it works. There are fixed non-halting
behavior patterns as soon as one of them is exactly matched H knows that
its input never halts.
> Even if H uses some adaptive process, where if it sees that it is
> deciding on a copy of itself, it increase how long it waits, it runs
> into the issue that THAT H will also see that same thing and increase
> its time too, causing the outer H to not wait long enough, or it needs
> to detect this adjustment and adjust its self too. The problem here is
> that H won't ever actually get to the point to be able to make the
> decision, so H fails to be a decider.
>
> This basically just proves that just trying to simulate will lead to
> cases where the decider can't decider and just fails.
>
> Ultimately, H needs to have some logic to break the otherwise infinite
> simulation loop, and your aborting criteria is a step in the right
> dirction, it makes the error of assuming that the inner simulators won't
> abort the simulation, while we KNOW that for H to be able to answer, it
> WILL abort the simulation, so the logic used must take that into
> account, which is a much harder problem (actually impossible).
>
> It has been previously shown that if you can detect this recusive case
> (which actually isn't as easy as you think when you try to implement it
> fully following the rules) then you can build an H that handles many of
> the recusive (but non-contrary) situations and get the right answer, but
> for the case of H^, the machine just gets into a state where it knows it
> is going to be wrong, but there is no allowable answer it can give in
> that case and be right, so it needs to be wrong, it just gets a choice
> in how it will be wrong.
>
>>
>> It took me 17 years and 12-16 thousand hours to come up with that. That
>> is the crux of the essence of my whole solution. That same simple rule
>> correctly decides the halt status of all inputs pathological or not.
>
> And you still don't have the right handle on the problem.
>
> You rule doesn't match the actual definition of Halting (at least the
> way you apply it), so you get the wrong answer.
>
>>
>>> H(<P>,<I>) is required, if it is to be correct, to give an answer that
>>> matches the bahavior of P(I). PERIOD. DEFINITION.
>>>
>>> Key point, the simulation by H of <P> <I> doesn't change the actual
>>> behavior of P(I). If H aborts the simulation of <P> <I> before that
>>> simulation reaches it final halting state (if it has one) doesn't make
>>> the machine non-halting, or the input represent a non-halting
>>> computation.
>>>
>>>
>>>>
>>>> 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
>>>>
>>>> To bypass the pathology of pathological inputs:
>>>
>>> I.E. Because I don't like the results of the above definition, I will
>>> create my own POOP based on a different criteria. You don't get to
>>> change the definitions. PERIOD.
>>>
>>>> In computability theory, the halting problem is the
>>>> problem of determining, from a description of an arbitrary
>>>> computer program and an input,
>>>>
>>>> whether the simulation of this program must be aborted to
>>>> prevent it from running forever.
>>>
>>> The correctness of this sentence hangs on the meaning that have been
>>> assigned to the words.
>>>
>>>>
>>>> The above criteria is valid on the basis of the known equivalence
>>>> between the direct execution of a computation and its simulation
>>>> by a UTM. The same criteria universally works on all inputs allowing
>>>> their halting status to be correctly decided.
>>>>
>>>
>>> Right, if it means that IF and only IF UTM(<P>, <I>) is non-halting,
>>> then H(<P>, <I>) should return the non-halting answer and if
>>> UTM(<P>,<I>) is Halting then H(<P>,<I>) should return the halting answer.
>>>
>>> If you means something different, then the criteria is FALSE.
>>>
>>> By the RIGHT interpretation, we KNOW that UTM(<H^>, <H^>) will halt if H
>>> says H(<H^>,<H^>) is non-halting, so the non-halting answer of H is
>>> wrong. PERIDD.
>>>
>>>
>>> You make the mistake of assuming a partial simulator is a UTM. It isn't.
>>> Just as you are not immortal just because you are still currently living.
>>>
>>
>>
>
--
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-09-03 17:31 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <FuwYI.417$g_4.318@fx14.iad> |
| In reply to | #38768 |
On 9/3/21 5:23 PM, olcott wrote:
> On 9/3/2021 3:58 PM, Richard Damon wrote:
>> On 9/3/21 4:11 PM, olcott wrote:
>>> On 9/3/2021 11:49 AM, Richard Damon wrote:
>>>> On 9/3/21 10:05 AM, olcott wrote:
>>>>> On 9/2/2021 11:59 PM, André G. Isaak wrote:
>>>>>> On 2021-09-02 22:09, olcott wrote:
>>>>>>> On 9/2/2021 10:52 PM, Richard Damon wrote:
>>>>>>>> On 9/2/21 11:18 PM, olcott wrote:
>>>>>>
>>>>>>>>> Any input that never halts unless its simulation is aborted is an
>>>>>>>>> input
>>>>>>>>> that never halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Bad Terminology. Inputs themselves don't halt. They only represent
>>>>>>>> computations that might be halting or not.
>>>>>>>>
>>>>>>>
>>>>>>> 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
>>>>>>>
>>>>>>> To bypass the pathology of pathological inputs:
>>>>>>> In computability theory, the halting problem is the
>>>>>>> problem of determining, from a description of an arbitrary
>>>>>>> computer program and an input,
>>>>>>>
>>>>>>> whether the simulation of this input must be aborted to
>>>>>>> prevent it from running forever.
>>>>>>>
>>>>>>> The above criteria is valid on the basis of the known equivalence
>>>>>>> between the direct execution of a computation and its simulation
>>>>>>> by a
>>>>>>> UTM. The same criteria universally works on all inputs.
>>>>>>
>>>>>> But the direct execution of P(P) *does* halt. So if there is an
>>>>>> equivalence between direct execution and simulation by a UTM, then
>>>>>> the
>>>>>> simulation by a UTM must also halt.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> The direct execution of P has a dependency on the H(P,P) that it
>>>>> calls.
>>>>> int main(){ P(P); } only halts because its call to H(P,P) returns
>>>>> 0. No
>>>>> instance of H(P,P) has any dependency on the return value of another
>>>>> function.
>>>>>
>>>>> This makes int main(){ P(P); } a computationally distinct different
>>>>> computation than H(P,P) that has no such dependency.
>>>>>
>>>>> You can dance all around this yet there exists no correct rebuttal in
>>>>> the universe that shows that these computations are equivalent or that
>>>>> computations that are not equivalent must have equivalent behavior.
>>>>
>>>> But that dance you make doesn't get around the DEFINITION of what H is
>>>> supposed to answer.
>>>>
>>>
>>> H(P,P) is supposed to answer whether or not its input would halt on its
>>> input.
>>>
>>> This part seems to be beyond your capacity to understand:
>>
>> No, it seemt the question that is actually being asked is beyond YOUR
>> understanding, even though you can parrot the words.
>>
>> A Halt Decider is supposed to answer whether or not the MACHINE + INPUT
>> REPRESENTED by its input would halt or not when run given that input.
>>
>> 'Inputs' don't do anything, only the actual machines they represent.
>>
>>>
>>> If H is required to abort its simulation of its input to prevent the
>>> simulation from running forever then this means that the input specifies
>>> infinite execution.
>>
>> Yes, H is in a tough position, an actually untenable position, which is
>> part of the reason the task can shown to be impossible. Your problem is
>> you keep on trying to add in an assumption that it can be done.
>>
>> If H uses some fixed amount of simulation to try to decide, then it sees
>> a copy of itself that has done less work then itself, that to predict
>> what it will do, it needs to run it to its decision point, but as it
>> gives itself more time, that other copy will also take more time, so it
>> will never see it making the decision. It fails because it can't find an
>> x such that x > x+1.
>>
>
> That is simply not the way that it works. There are fixed non-halting
> behavior patterns as soon as one of them is exactly matched H knows that
> its input never halts.
And the pattern you detect is obviously not properly one of them,
because the machine that you detect it in doesn't halt when run.
A pattern that is present is some halting computation can not be used as
proof that a computation is non-halting.
That is like looking for cats, and knowing that some cats are black,
when you see a black dog you say thats a cat because it is black like
that black cat I saw.
Yes, that pattern exists in some non-halting machines, but it also
exists in Halting machines, because it isn't specific enough (in part
because it intentionally doesn't look at some of the behavior).
WRONG patterns give you wrong answers.
H^(<H^>) is admitted even by you to be halting, so <H^> <H^> is a
representation of a Halting Computation.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-03 06:32 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <9RmYI.9306$%Z2.8554@fx06.iad> |
| In reply to | #38718 |
On 9/3/21 12:09 AM, olcott wrote: > On 9/2/2021 10:52 PM, Richard Damon wrote: >> On 9/2/21 11:18 PM, olcott wrote: >>> On 9/2/2021 10:09 PM, Richard Damon wrote: >>>> On 9/2/21 10:55 PM, olcott wrote: >>>>> On 9/2/2021 9:42 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> On 9/2/2021 8:29 PM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>> >>>>>>>>> On 9/2/2021 8:05 PM, Ben Bacarisse wrote: >>>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>>> >>>>>>>>>>> On 9/2/2021 7:27 PM, Ben Bacarisse wrote: >>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>>> >>>>>>>>>>>>> Anyone that understands what I am saying can tell that their >>>>>>>>>>>>> have been >>>>>>>>>>>>> zero actual rebuttals. >>>>>>>>>>>> >>>>>>>>>>>> Is that an empty set? Does anyone in the world understand and >>>>>>>>>>>> agree >>>>>>>>>>>> with you? Someone at the grocery store maybe? >>>>>>>>>> Well? Does anyone in the world understand and agree with you? >>>>>>>>>> Will you >>>>>>>>>> avoid every question put to you? >>>>>>>>>> >>>>>>>>>>> None of the rebuttals ever directly addressed any of the points >>>>>>>>>>> that I >>>>>>>>>>> made. They always changed the subject to another different >>>>>>>>>>> unrelated >>>>>>>>>>> point. >>>>>>>>>> Flat-out lie. You made this point crucial point on 12th Aug: >>>>>>>>>> "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting >>>>>>>>>> computation." >>>>>>>>> >>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ // You pay attention to this >>>>>>>>> Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ // You utterly ignore this >>>>>>>> >>>>>>>> Liar. I have addressed this on many occasions. Here, yet >>>>>>>> again, is >>>>>>>> what I have to say about it. You show us that Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊦ >>>>>>>> Ĥ.qn >>>>>>>> and >>>>>>>> since ⟨Ĥ1⟩ = ⟨Ĥ2⟩ = ⟨Ĥ⟩ we see that H (embedded as it is at Ĥ.qx) >>>>>>>> rejects the string ⟨Ĥ⟩ ⟨Ĥ⟩. How you think I knew that? I don't >>>>>>>> make >>>>>>>> this stuff up, you do. >>>>>>> >>>>>>> The simple fact that you ignore is that the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ >>>>>>> never halts unless Ĥ.qx aborts its simulation of this input. >>>>>>> You have dodged this EVER SINCE 2017-03-11 (4.5 years ago) >>>>>> >>>>>> Liar. Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ transitions to Ĥ.qn. >>>>> >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>> >>>>> When I say that I have a brown dog is it not a >>>>> rebuttal to say that I don't have a white cat. >>>>> >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>> >>>>> You have been dishonestly denying this for 4.5 years. >>>>> You have been dishonestly denying this for 4.5 years. >>>>> You have been dishonestly denying this for 4.5 years. >>>>> You have been dishonestly denying this for 4.5 years. >>>>> >>>> >>>> INPUTS DON'T HALT, >>>> >>> >>> Any input that never halts unless its simulation is aborted is an input >>> that never halts. >>> >> >> Bad Terminology. Inputs themselves don't halt. They only represent >> computations that might be halting or not. >> > > 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 Right. Note, it says whether 'The Program' not 'The Input' will halt or not. Programs will Halt, not inputs. Inputs are just the desciption used to specify the program. > > To bypass the pathology of pathological inputs: FAIL. You don't get to change the definition because you don't like the problems it creates. > In computability theory, the halting problem is the > problem of determining, from a description of an arbitrary > computer program and an input, > > whether the simulation of this input must be aborted to > prevent it from running forever. Ok, whether the simulation of THIS input (not some other simulation, THIS one). > > The above criteria is valid on the basis of the known equivalence > between the direct execution of a computation and its simulation by a > UTM. The same criteria universally works on all inputs. And by that, the question is to decide if H^1(<H^2> is Halting or not, do we need to abort the simulation of H^1(<H^2>) or will it stop on its own if simulated. Simulating this machine it will halt because H will abort a different simulation, the simulation of H^2(<H^3>), call it non-halting and thus H^1 will halt. FAIL. The fact that H will (incorrectly) abort the simulation doesn't matter, H isn't a UTM, so the fact that it aborted the program in a not-yet-halted state doesn't show either Halting or non-halting. The ACTUAL UTM simulation of that input shows that it WILL Halt. You seem to confuse aborting a simulation before it finishes with a pure simulation never reaching a halting state. If you have a maze that may have a prize in it, you can't just search for a while and then give up and declare there is no prize, you need to continue until you either find the prize or can show you have atually searched everywhere. > > >> Error in Kind. >> >> Sort of like saying that a loud speaker can lie. The loud speaker just >> reproduces the signal sent to it, so if the words that came out of the >> loud speaker were wrong, it isn't the loud speaker that actually lied, >> it is the signal sent to it, or the source of the signal that is the >> source of the lie. >> >> The input doesn't do ANYTHING on its own. Halting a a behavior of a >> Computation, not just the representation of it. >> >> >> If the simulation is REALLY a Pure Simulation (not one that is aborted). >> >> A pure simulaiton of <H^1> <H^2> does Halt, it does EXACTLY what the top >> level H^(<H^>) does. >> >> > >
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2021-09-03 04:47 -0700 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <ee0470db-16b0-4f4b-b86e-57b2526d3bcfn@googlegroups.com> |
| In reply to | #38721 |
On Friday, 3 September 2021 at 11:32:41 UTC+1, richar...@gmail.com wrote: > On 9/3/21 12:09 AM, olcott wrote: > > On 9/2/2021 10:52 PM, Richard Damon wrote: > >> On 9/2/21 11:18 PM, olcott wrote: > >>> On 9/2/2021 10:09 PM, Richard Damon wrote: > >>>> On 9/2/21 10:55 PM, olcott wrote: > >>>>> On 9/2/2021 9:42 PM, Ben Bacarisse wrote: > >>>>>> olcott <No...@NoWhere.com> writes: > >>>>>> > >>>>>>> On 9/2/2021 8:29 PM, Ben Bacarisse wrote: > >>>>>>>> olcott <No...@NoWhere.com> writes: > >>>>>>>> > >>>>>>>>> On 9/2/2021 8:05 PM, Ben Bacarisse wrote: > >>>>>>>>>> olcott <No...@NoWhere.com> writes: > >>>>>>>>>> > >>>>>>>>>>> On 9/2/2021 7:27 PM, Ben Bacarisse wrote: > >>>>>>>>>>>> olcott <No...@NoWhere.com> writes: > >>>>>>>>>> > >>>>>>>>>>>>> Anyone that understands what I am saying can tell that their > >>>>>>>>>>>>> have been > >>>>>>>>>>>>> zero actual rebuttals. > >>>>>>>>>>>> > >>>>>>>>>>>> Is that an empty set? Does anyone in the world understand and > >>>>>>>>>>>> agree > >>>>>>>>>>>> with you? Someone at the grocery store maybe? > >>>>>>>>>> Well? Does anyone in the world understand and agree with you? > >>>>>>>>>> Will you > >>>>>>>>>> avoid every question put to you? > >>>>>>>>>> > >>>>>>>>>>> None of the rebuttals ever directly addressed any of the points > >>>>>>>>>>> that I > >>>>>>>>>>> made. They always changed the subject to another different > >>>>>>>>>>> unrelated > >>>>>>>>>>> point. > >>>>>>>>>> Flat-out lie. You made this point crucial point on 12th Aug: > >>>>>>>>>> "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting > >>>>>>>>>> computation." > >>>>>>>>> > >>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ // You pay attention to this > >>>>>>>>> Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ // You utterly ignore this > >>>>>>>> > >>>>>>>> Liar. I have addressed this on many occasions. Here, yet > >>>>>>>> again, is > >>>>>>>> what I have to say about it. You show us that Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊦ > >>>>>>>> Ĥ.qn > >>>>>>>> and > >>>>>>>> since ⟨Ĥ1⟩ = ⟨Ĥ2⟩ = ⟨Ĥ⟩ we see that H (embedded as it is at Ĥ.qx) > >>>>>>>> rejects the string ⟨Ĥ⟩ ⟨Ĥ⟩. How you think I knew that? I don't > >>>>>>>> make > >>>>>>>> this stuff up, you do. > >>>>>>> > >>>>>>> The simple fact that you ignore is that the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ > >>>>>>> never halts unless Ĥ.qx aborts its simulation of this input. > >>>>>>> You have dodged this EVER SINCE 2017-03-11 (4.5 years ago) > >>>>>> > >>>>>> Liar. Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ transitions to Ĥ.qn. > >>>>> > >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. > >>>>> > >>>>> When I say that I have a brown dog is it not a > >>>>> rebuttal to say that I don't have a white cat. > >>>>> > >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. > >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. > >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. > >>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. > >>>>> > >>>>> You have been dishonestly denying this for 4.5 years. > >>>>> You have been dishonestly denying this for 4.5 years. > >>>>> You have been dishonestly denying this for 4.5 years. > >>>>> You have been dishonestly denying this for 4.5 years. > >>>>> > >>>> > >>>> INPUTS DON'T HALT, > >>>> > >>> > >>> Any input that never halts unless its simulation is aborted is an input > >>> that never halts. > >>> > >> > >> Bad Terminology. Inputs themselves don't halt. They only represent > >> computations that might be halting or not. > >> > > > > 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 > Right. Note, it says whether 'The Program' not 'The Input' will halt or > not. > > Programs will Halt, not inputs. Inputs are just the desciption used to > specify the program. > There seems to be some sort of claim that whilest H_Hat<H_Hat> is halting, the string pair <H_Hat><H_Hat> (angle brackets represent tape contents) is non-halting. I really can't get to the bottom of what exactly is being claimed here. > > > > To bypass the pathology of pathological inputs: > FAIL. You don't get to change the definition because you don't like the > problems it creates. > You can't "solve the halting problem". You can maybe propose a set which has some relationship to the halting / non-halting sets of Turing machines, and has interesting properties. That's not really a FAIL, unless you set yourself the insane goal of "solving the halting problem". Trying to define a set of "pathological inputs" isn't an example of something which is original, however,, and it's well known to be a dead end.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-03 14:41 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <87a6ktvkss.fsf@bsb.me.uk> |
| In reply to | #38722 |
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >> Programs will Halt, not inputs. Inputs are just the desciption used to >> specify the program. >> > There seems to be some sort of claim that whilest H_Hat<H_Hat> is > halting, the string pair <H_Hat><H_Hat> (angle brackets represent tape > contents) is non-halting. I really can't get to the bottom of what exactly is > being claimed here. I think that's deliberate, now. Several people have tried to get him to use terms correctly (or, as a last resort, invent new well-defined ones), but he won't do that because the obfuscation is all he has left. He has said "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting computation" (Aug 2021) This is as wrong as saying "2 plus 2 is not 4" but when it's pointed out that ⟨Ĥ⟩ ⟨Ĥ⟩ /does/ encode a halting computation he says "the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts" (Aug 2021) which is akin to responding to the fact that 2+2=4 with "the input to 2a plus 2b goes not four". The bad wording is seems suspiciously deliberate. What else has he got? He hopes, I think, that people will argue about the bad wording and not challenge the basic error. > ... unless you set yourself the insane goal of "solving the halting > problem". PO has claimed, in a court of law, to be God. I think we can safely say that his relationship with reality is... er... fragile. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 09:20 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <Guqdnd5wZNy0sq_8nZ2dnUU7-R3NnZ2d@giganews.com> |
| In reply to | #38723 |
On 9/3/2021 8:41 AM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>>> Programs will Halt, not inputs. Inputs are just the desciption used to
>>> specify the program.
>>>
>> There seems to be some sort of claim that whilest H_Hat<H_Hat> is
>> halting, the string pair <H_Hat><H_Hat> (angle brackets represent tape
>> contents) is non-halting. I really can't get to the bottom of what exactly is
>> being claimed here.
>
> I think that's deliberate, now. Several people have tried to get him to
> use terms correctly (or, as a last resort, invent new well-defined
> ones), but he won't do that because the obfuscation is all he has left.
>
Ĥ.q0 ⟨Ĥ1⟩ // is equivalent to int main() { P(P); }
Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ // is equivalent to H(P,P)
The H(P,P) C/x86 code makes a perfect and complete analogy to the
Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ Turing machine code. If you don't understand the x86
language well enough you won't be able to ever understand what I am saying.
All of the actual Turing Machine base proofs must leave out almost all
of the details because their programs would hundreds of thousands of
pages. A TM with random access memory would be far less of a nightmare
to deal with.
It is obvious that every simulation of P(P) would never halt unless H
aborts its simulation of P(P) to everyone one sufficiently understanding
the material.
It is obvious to everyone one sufficiently understanding the material
that all "rebuttals" are based on either deception or failing to
understand the material.
I show that X is true because of Y and the "rebuttal" essentially takes
the form: "I just don't believe that".
> He has said
>
> "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting computation" (Aug
> 2021)
>
> This is as wrong as saying "2 plus 2 is not 4" but when it's pointed out
> that ⟨Ĥ⟩ ⟨Ĥ⟩ /does/ encode a halting computation he says
>
> "the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts" (Aug 2021)
>
> which is akin to responding to the fact that 2+2=4 with "the input to 2a
> plus 2b goes not four".
>
> The bad wording is seems suspiciously deliberate. What else has he got?
> He hopes, I think, that people will argue about the bad wording and not
> challenge the basic error.
>
>> ... unless you set yourself the insane goal of "solving the halting
>> problem".
>
> PO has claimed, in a court of law, to be God. I think we can safely say
> that his relationship with reality is... er... fragile.
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-03 15:58 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <87y28du2nx.fsf@bsb.me.uk> |
| In reply to | #38728 |
olcott <NoOne@NoWhere.com> writes:
> On 9/3/2021 8:41 AM, Ben Bacarisse wrote:
>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>
>>>> Programs will Halt, not inputs. Inputs are just the desciption used to
>>>> specify the program.
>>>>
>>> There seems to be some sort of claim that whilest H_Hat<H_Hat> is
>>> halting, the string pair <H_Hat><H_Hat> (angle brackets represent tape
>>> contents) is non-halting. I really can't get to the bottom of what exactly is
>>> being claimed here.
>> I think that's deliberate, now. Several people have tried to get him to
>> use terms correctly (or, as a last resort, invent new well-defined
>> ones), but he won't do that because the obfuscation is all he has left.
>
> Ĥ.q0 ⟨Ĥ1⟩ // is equivalent to int main() { P(P); }
> Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ // is equivalent to H(P,P)
What string encodes the halting computation of Ĥ applied to ⟨Ĥ⟩?
Shall we see how many times you don't answer this simple question? It's
at least half a dozen times already, given that I am not the only person
to have asked it.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 08:51 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <f9OdnQIvwJjlta_8nZ2dnUU7-dPNnZ2d@giganews.com> |
| In reply to | #38722 |
On 9/3/2021 6:47 AM, Malcolm McLean wrote:
> On Friday, 3 September 2021 at 11:32:41 UTC+1, richar...@gmail.com wrote:
>> On 9/3/21 12:09 AM, olcott wrote:
>>> On 9/2/2021 10:52 PM, Richard Damon wrote:
>>>> On 9/2/21 11:18 PM, olcott wrote:
>>>>> On 9/2/2021 10:09 PM, Richard Damon wrote:
>>>>>> On 9/2/21 10:55 PM, olcott wrote:
>>>>>>> On 9/2/2021 9:42 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 9/2/2021 8:29 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 9/2/2021 8:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/2/2021 7:27 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>>>> Anyone that understands what I am saying can tell that their
>>>>>>>>>>>>>>> have been
>>>>>>>>>>>>>>> zero actual rebuttals.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Is that an empty set? Does anyone in the world understand and
>>>>>>>>>>>>>> agree
>>>>>>>>>>>>>> with you? Someone at the grocery store maybe?
>>>>>>>>>>>> Well? Does anyone in the world understand and agree with you?
>>>>>>>>>>>> Will you
>>>>>>>>>>>> avoid every question put to you?
>>>>>>>>>>>>
>>>>>>>>>>>>> None of the rebuttals ever directly addressed any of the points
>>>>>>>>>>>>> that I
>>>>>>>>>>>>> made. They always changed the subject to another different
>>>>>>>>>>>>> unrelated
>>>>>>>>>>>>> point.
>>>>>>>>>>>> Flat-out lie. You made this point crucial point on 12th Aug:
>>>>>>>>>>>> "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting
>>>>>>>>>>>> computation."
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ // You pay attention to this
>>>>>>>>>>> Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ // You utterly ignore this
>>>>>>>>>>
>>>>>>>>>> Liar. I have addressed this on many occasions. Here, yet
>>>>>>>>>> again, is
>>>>>>>>>> what I have to say about it. You show us that Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊦
>>>>>>>>>> Ĥ.qn
>>>>>>>>>> and
>>>>>>>>>> since ⟨Ĥ1⟩ = ⟨Ĥ2⟩ = ⟨Ĥ⟩ we see that H (embedded as it is at Ĥ.qx)
>>>>>>>>>> rejects the string ⟨Ĥ⟩ ⟨Ĥ⟩. How you think I knew that? I don't
>>>>>>>>>> make
>>>>>>>>>> this stuff up, you do.
>>>>>>>>>
>>>>>>>>> The simple fact that you ignore is that the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>> never halts unless Ĥ.qx aborts its simulation of this input.
>>>>>>>>> You have dodged this EVER SINCE 2017-03-11 (4.5 years ago)
>>>>>>>>
>>>>>>>> Liar. Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ transitions to Ĥ.qn.
>>>>>>>
>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.
>>>>>>>
>>>>>>> When I say that I have a brown dog is it not a
>>>>>>> rebuttal to say that I don't have a white cat.
>>>>>>>
>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.
>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.
>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.
>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.
>>>>>>>
>>>>>>> You have been dishonestly denying this for 4.5 years.
>>>>>>> You have been dishonestly denying this for 4.5 years.
>>>>>>> You have been dishonestly denying this for 4.5 years.
>>>>>>> You have been dishonestly denying this for 4.5 years.
>>>>>>>
>>>>>>
>>>>>> INPUTS DON'T HALT,
>>>>>>
>>>>>
>>>>> Any input that never halts unless its simulation is aborted is an input
>>>>> that never halts.
>>>>>
>>>>
>>>> Bad Terminology. Inputs themselves don't halt. They only represent
>>>> computations that might be halting or not.
>>>>
>>>
>>> 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
>> Right. Note, it says whether 'The Program' not 'The Input' will halt or
>> not.
>>
>> Programs will Halt, not inputs. Inputs are just the desciption used to
>> specify the program.
>>
> There seems to be some sort of claim that whilest H_Hat<H_Hat> is
> halting, the string pair <H_Hat><H_Hat> (angle brackets represent tape
> contents) is non-halting. I really can't get to the bottom of what exactly is
> being claimed here.
The H(P,P) C/x86 code makes a perfect and complete analogy to the
Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ Turing machine code. If you don't understand the x86
language well enough you won't be able to ever understand what I am saying.
All of the actual Turing Machine base proofs must leave out almost all
of the details because their programs would hundreds of thousands of
pages. A TM with random access memory would be far less of a nightmare
to deal with.
>>>
>>> To bypass the pathology of pathological inputs:
>> FAIL. You don't get to change the definition because you don't like the
>> problems it creates.
>>
> You can't "solve the halting problem". You can maybe propose a set which has
> some relationship to the halting / non-halting sets of Turing machines, and
> has interesting properties. That's not really a FAIL, unless you set yourself the
> insane goal of "solving the halting problem".
> Trying to define a set of "pathological inputs" isn't an example of something
> which is original, however,, and it's well known to be a dead end.
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
To bypass the pathology of pathological inputs:
In computability theory, the halting problem is the
problem of determining, from a description of an arbitrary
computer program and an input,
whether the simulation of this program must be aborted to
prevent it from running forever.
The above criteria is valid on the basis of the known equivalence
between the direct execution of a computation and its simulation
by a UTM. The same criteria universally works on all inputs allowing
their halting status to be correctly decided.
--
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-09-03 08:09 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <sgtabg$pcf$1@dont-email.me> |
| In reply to | #38724 |
On 2021-09-03 07:51, olcott wrote: > All of the actual Turing Machine base proofs must leave out almost all > of the details because their programs would hundreds of thousands of > pages. A TM with random access memory would be far less of a nightmare > to deal with. You keep making this absurd claim without actually backing it up. What details do you imagine are being left out? And why do you assume a program would be 'hundreds of thousands of pages'? I gave you a link to a paper which described a number of UTMs. In most cases the complete description of the UTM was a single page in length. I assume that that is much shorter than the source code for your x86 simulator. André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 09:24 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <b6WdnWwDM5SDra_8nZ2dnUU7-dHNnZ2d@giganews.com> |
| In reply to | #38727 |
On 9/3/2021 9:09 AM, André G. Isaak wrote: > On 2021-09-03 07:51, olcott wrote: > >> All of the actual Turing Machine base proofs must leave out almost all >> of the details because their programs would hundreds of thousands of >> pages. A TM with random access memory would be far less of a nightmare >> to deal with. > > You keep making this absurd claim without actually backing it up. > > What details do you imagine are being left out? > The halt deciding code is never shown, it is merely assumed to be impossible. > And why do you assume a program would be 'hundreds of thousands of > pages'? I gave you a link to a paper which described a number of UTMs. Simply moving from one tape location to another tape location one megabyte away takes one million steps. > In most cases the complete description of the UTM was a single page in > length. I assume that that is much shorter than the source code for your > x86 simulator. > > André > It is never a complete description of any actual Turing machine it is only at most a template of a TM description. -- 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-09-03 08:33 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <sgtbo4$4mi$1@dont-email.me> |
| In reply to | #38729 |
On 2021-09-03 08:24, olcott wrote: > On 9/3/2021 9:09 AM, André G. Isaak wrote: >> On 2021-09-03 07:51, olcott wrote: >> >>> All of the actual Turing Machine base proofs must leave out almost >>> all of the details because their programs would hundreds of thousands >>> of pages. A TM with random access memory would be far less of a >>> nightmare to deal with. >> >> You keep making this absurd claim without actually backing it up. >> >> What details do you imagine are being left out? >> > > The halt deciding code is never shown, it is merely assumed to be > impossible. It is not 'assumed' to be impossible. It is proven to be impossible. How can you show impossible code? I think part of your confusion stems from the fact that you seem to think that Linz's H and H_Hat are Turing Machines. They are not. They are *variables*. >> And why do you assume a program would be 'hundreds of thousands of >> pages'? I gave you a link to a paper which described a number of UTMs. > > Simply moving from one tape location to another tape location one > megabyte away takes one million steps. And moving a gigabyte of data from one memory location to another may take a billion steps, but only involves a few lines of C code. Ditto for Turing Machines. The number of steps isn't what's relevant. >> In most cases the complete description of the UTM was a single page in >> length. I assume that that is much shorter than the source code for >> your x86 simulator. >> >> André >> > > It is never a complete description of any actual Turing machine it is > only at most a template of a TM description. The paper gives *complete* descriptions of these UTMs, each taking around a page. The problem is you refuse to read the paper. -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 09:46 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <u7WdnVW7ruvQqK_8nZ2dnUU7-WXNnZ2d@giganews.com> |
| In reply to | #38730 |
On 9/3/2021 9:33 AM, André G. Isaak wrote:
> On 2021-09-03 08:24, olcott wrote:
>> On 9/3/2021 9:09 AM, André G. Isaak wrote:
>>> On 2021-09-03 07:51, olcott wrote:
>>>
>>>> All of the actual Turing Machine base proofs must leave out almost
>>>> all of the details because their programs would hundreds of
>>>> thousands of pages. A TM with random access memory would be far less
>>>> of a nightmare to deal with.
>>>
>>> You keep making this absurd claim without actually backing it up.
>>>
>>> What details do you imagine are being left out?
>>>
>>
>> The halt deciding code is never shown, it is merely assumed to be
>> impossible.
>
> It is not 'assumed' to be impossible. It is proven to be impossible. How
> can you show impossible code?
>
It is "proven" to be impossible by making sure to not carefully examine
applying a simulating halt deciding that uses this criteria:
In computability theory, the halting problem is the
problem of determining, from a description of an arbitrary
computer program and an input,
whether the simulation of this program must be aborted to
prevent it from running forever.
> I think part of your confusion stems from the fact that you seem to
> think that Linz's H and H_Hat are Turing Machines. They are not. They
> are *variables*.
>
>>> And why do you assume a program would be 'hundreds of thousands of
>>> pages'? I gave you a link to a paper which described a number of UTMs.
>>
>> Simply moving from one tape location to another tape location one
>> megabyte away takes one million steps.
>
> And moving a gigabyte of data from one memory location to another may
> take a billion steps, but only involves a few lines of C code.
>
> Ditto for Turing Machines. The number of steps isn't what's relevant.
>
It sure as Hell is if you want to provide the complete source-code.
Millions of pages of code is utterly infeasible.
>>> In most cases the complete description of the UTM was a single page
>>> in length. I assume that that is much shorter than the source code
>>> for your x86 simulator.
>>>
>>> André
>>>
>>
>> It is never a complete description of any actual Turing machine it is
>> only at most a template of a TM description.
>
> The paper gives *complete* descriptions of these UTMs, each taking
> around a page. The problem is you refuse to read the paper.
>
--
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-09-03 09:12 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <sgte0h$maa$1@dont-email.me> |
| In reply to | #38731 |
On 2021-09-03 08:46, olcott wrote: > On 9/3/2021 9:33 AM, André G. Isaak wrote: >> On 2021-09-03 08:24, olcott wrote: >>> On 9/3/2021 9:09 AM, André G. Isaak wrote: >>>> On 2021-09-03 07:51, olcott wrote: >>>> >>>>> All of the actual Turing Machine base proofs must leave out almost >>>>> all of the details because their programs would hundreds of >>>>> thousands of pages. A TM with random access memory would be far >>>>> less of a nightmare to deal with. >>>> >>>> You keep making this absurd claim without actually backing it up. >>>> >>>> What details do you imagine are being left out? >>>> >>> >>> The halt deciding code is never shown, it is merely assumed to be >>> impossible. >> >> It is not 'assumed' to be impossible. It is proven to be impossible. >> How can you show impossible code? >> > > It is "proven" to be impossible by making sure to not carefully examine > applying a simulating halt deciding that uses this criteria: The proof makes no assumption about how the halt decider works. It applies just as much to a 'simulating halt decider' as to any other type of decider. > In computability theory, the halting problem is the > problem of determining, from a description of an arbitrary > computer program and an input, > > whether the simulation of this program must be aborted to > prevent it from running forever. > >> I think part of your confusion stems from the fact that you seem to >> think that Linz's H and H_Hat are Turing Machines. They are not. They >> are *variables*. >> >>>> And why do you assume a program would be 'hundreds of thousands of >>>> pages'? I gave you a link to a paper which described a number of UTMs. >>> >>> Simply moving from one tape location to another tape location one >>> megabyte away takes one million steps. >> >> And moving a gigabyte of data from one memory location to another may >> take a billion steps, but only involves a few lines of C code. >> >> Ditto for Turing Machines. The number of steps isn't what's relevant. >> > > It sure as Hell is if you want to provide the complete source-code. > Millions of pages of code is utterly infeasible. The state transitions needed to move the head a million places *don't* require millions of page to describe any more than the C code needed to move a gigabyte of data from one location to another do. >>>> In most cases the complete description of the UTM was a single page >>>> in length. I assume that that is much shorter than the source code >>>> for your x86 simulator. >>>> >>>> André >>>> >>> >>> It is never a complete description of any actual Turing machine it is >>> only at most a template of a TM description. >> >> The paper gives *complete* descriptions of these UTMs, each taking >> around a page. The problem is you refuse to read the paper. >> > -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 10:28 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <CrSdnSnNk7inoq_8nZ2dnUU7-f3NnZ2d@giganews.com> |
| In reply to | #38738 |
On 9/3/2021 10:12 AM, André G. Isaak wrote: > On 2021-09-03 08:46, olcott wrote: >> On 9/3/2021 9:33 AM, André G. Isaak wrote: >>> On 2021-09-03 08:24, olcott wrote: >>>> On 9/3/2021 9:09 AM, André G. Isaak wrote: >>>>> On 2021-09-03 07:51, olcott wrote: >>>>> >>>>>> All of the actual Turing Machine base proofs must leave out almost >>>>>> all of the details because their programs would hundreds of >>>>>> thousands of pages. A TM with random access memory would be far >>>>>> less of a nightmare to deal with. >>>>> >>>>> You keep making this absurd claim without actually backing it up. >>>>> >>>>> What details do you imagine are being left out? >>>>> >>>> >>>> The halt deciding code is never shown, it is merely assumed to be >>>> impossible. >>> >>> It is not 'assumed' to be impossible. It is proven to be impossible. >>> How can you show impossible code? >>> >> >> It is "proven" to be impossible by making sure to not carefully >> examine applying a simulating halt deciding that uses this criteria: > > The proof makes no assumption about how the halt decider works. It > applies just as much to a 'simulating halt decider' as to any other type > of decider. > >> In computability theory, the halting problem is the >> problem of determining, from a description of an arbitrary >> computer program and an input, >> >> whether the simulation of this program must be aborted to >> prevent it from running forever. If the "proof" tried to prove that the above criteria fail it would fail to prove that the above criteria fail. >> >>> I think part of your confusion stems from the fact that you seem to >>> think that Linz's H and H_Hat are Turing Machines. They are not. They >>> are *variables*. >>> >>>>> And why do you assume a program would be 'hundreds of thousands of >>>>> pages'? I gave you a link to a paper which described a number of UTMs. >>>> >>>> Simply moving from one tape location to another tape location one >>>> megabyte away takes one million steps. >>> >>> And moving a gigabyte of data from one memory location to another may >>> take a billion steps, but only involves a few lines of C code. >>> >>> Ditto for Turing Machines. The number of steps isn't what's relevant. >>> >> >> It sure as Hell is if you want to provide the complete source-code. >> Millions of pages of code is utterly infeasible. > > The state transitions needed to move the head a million places *don't* > require millions of page to describe any more than the C code needed to > move a gigabyte of data from one location to another do. > So in other words you are simply assuming a higher level of abstraction that provides what appears to be random memory access to a machine lacking RAM access. We could simply augment the tape head move operation with a repetition count. That sounds very promising. What would the underlying TM code actually look like to move the tape head five positions to the right? It can't keep a counter anywhere because it would have to move the tape head back to see the counter. >>>>> In most cases the complete description of the UTM was a single page >>>>> in length. I assume that that is much shorter than the source code >>>>> for your x86 simulator. >>>>> >>>>> André >>>>> >>>> >>>> It is never a complete description of any actual Turing machine it >>>> is only at most a template of a TM description. >>> >>> The paper gives *complete* descriptions of these UTMs, each taking >>> around a page. The problem is you refuse to read the paper. >>> >> > > -- 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-09-03 09:43 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <sgtfs1$50c$1@dont-email.me> |
| In reply to | #38741 |
On 2021-09-03 09:28, olcott wrote: >> The state transitions needed to move the head a million places *don't* >> require millions of page to describe any more than the C code needed >> to move a gigabyte of data from one location to another do. >> > > So in other words you are simply assuming a higher level of abstraction > that provides what appears to be random memory access to a machine No. I'm not doing that at all. > lacking RAM access. We could simply augment the tape head move operation > with a repetition count. That sounds very promising. You keep suggesting all these 'augmentations', all of which would result in things which *aren't* Turing Machines at all. Why not instead try working with *actual* Turing Machines instead of trying to change them into something more like the x86 machines you are more familiar with? You'd then learn that you can do very complicated things using only a very limited set of operations. > What would the underlying TM code actually look like to move the tape > head five positions to the right? It can't keep a counter anywhere > because it would have to move the tape head back to see the counter. The way for you to learn this is to look at some actual Turing Machines to see how they do this instead of making all sorts of erroneous assumptions about how they work. I've given you links to papers that describe TMs and UTMs with actual, concrete examples. You'd do well to actually *look* at some of these. There's no reason for people here to try to educate you about these things if you're not willing to do at least some of the work yourself. André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 15:01 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <TqmdnW5bHqye4q_8nZ2dnUU7-d_NnZ2d@giganews.com> |
| In reply to | #38746 |
On 9/3/2021 10:43 AM, André G. Isaak wrote: > On 2021-09-03 09:28, olcott wrote: > >>> The state transitions needed to move the head a million places >>> *don't* require millions of page to describe any more than the C code >>> needed to move a gigabyte of data from one location to another do. >>> >> >> So in other words you are simply assuming a higher level of >> abstraction that provides what appears to be random memory access to a >> machine > > No. I'm not doing that at all. > A turing machine program consists of a list of 'quintuples', each one of which is a five-symbol turing machine instruction. For example, the quintuple 'SCcsm' is executed by the machine if it is in state 'S' and is reading the symbol 'C' on the tape. In that case, the instruction causes the machine to make a transition to state 's' and to overwrite the symbol 'C' on the tape with the symbol 'c'. The last operation it performs under this instruction is to move the tape reading head one symbol to the left or right according to whether 'm' is 'l' or 'r'. http://www.lns.mit.edu/~dsw/turing/doc/tm_manual.txt This would require one million instructions to move to a tape head position one million positions away from the current position. >> lacking RAM access. We could simply augment the tape head move >> operation with a repetition count. That sounds very promising. > > You keep suggesting all these 'augmentations', all of which would result > in things which *aren't* Turing Machines at all. Why not instead try > working with *actual* Turing Machines instead of trying to change them > into something more like the x86 machines you are more familiar with? > You'd then learn that you can do very complicated things using only a > very limited set of operations. > >> What would the underlying TM code actually look like to move the tape >> head five positions to the right? It can't keep a counter anywhere >> because it would have to move the tape head back to see the counter. > > The way for you to learn this is to look at some actual Turing Machines > to see how they do this instead of making all sorts of erroneous > assumptions about how they work. > > I've given you links to papers that describe TMs and UTMs with actual, > concrete examples. You'd do well to actually *look* at some of these. > There's no reason for people here to try to educate you about these > things if you're not willing to do at least some of the work yourself. > > 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-09-03 14:24 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <sgu0a3$tk9$1@dont-email.me> |
| In reply to | #38755 |
On 2021-09-03 14:01, olcott wrote: > On 9/3/2021 10:43 AM, André G. Isaak wrote: >> On 2021-09-03 09:28, olcott wrote: >> >>>> The state transitions needed to move the head a million places >>>> *don't* require millions of page to describe any more than the C >>>> code needed to move a gigabyte of data from one location to another do. >>>> >>> >>> So in other words you are simply assuming a higher level of >>> abstraction that provides what appears to be random memory access to >>> a machine >> >> No. I'm not doing that at all. >> > > A turing machine program consists of a list of 'quintuples', each one of > which is a five-symbol turing machine instruction. For example, the > quintuple 'SCcsm' is executed by the machine if it is in state 'S' and > is reading the symbol 'C' on the tape. In that case, the instruction > causes the machine to make a transition to state 's' and to overwrite > the symbol 'C' on the tape with the symbol 'c'. The last operation it > performs under this instruction is to move the tape reading head one > symbol to the left or right according to whether 'm' is 'l' or 'r'. > http://www.lns.mit.edu/~dsw/turing/doc/tm_manual.txt I know what a Turing Machine is. You don't need to keep explaining this. > This would require one million instructions to move to a tape head > position one million positions away from the current position. It would require millions of *operations*. It would not require a Turing Machine which has millions of state transitions. This is no different from the example I gave of a C program which copies a gigabyte of RAM to another location. This would require billions of *instructions* to be executed, but the program itself would be very short. Thinking in terms of the number of operations performed is meaningless. All sorts of things you do on your computer involve executing *trillions* of instructions, but that doesn't mean the program itself is trillions of instructions long. Download a copy of the source code for VLC and print it out. Then print out a trace of VLC playing three hours of 4K video. The former is doable. You probably couldn't manage the latter since the world would likely run out of paper. And trees. -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
Page 16 of 37 — ← Prev page 1 … 14 15 [16] 17 18 … 37 Next page →
Back to top | Article view | comp.theory
csiph-web