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 17 of 37 — ← Prev page 1 … 15 16 [17] 18 19 … 37 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 15:31 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <ceudnVqLdpKjG6_8nZ2dnUU7-b3NnZ2d@giganews.com> |
| In reply to | #38758 |
On 9/3/2021 3:24 PM, André G. Isaak wrote: > 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. > It would require an in-feasibly large source-code listing. > 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. > I don't see how it could do any counter-loop because it would have to undo all the tape heads move just to look as the counter. If it can't do a counter-loop this seems to only leave moving the tape head to the right in one million sequential steps. > 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. > -- 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:58 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <sgu29b$ahu$1@dont-email.me> |
| In reply to | #38760 |
On 2021-09-03 14:31, olcott wrote: > On 9/3/2021 3:24 PM, André G. Isaak wrote: >> 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. >> > > It would require an in-feasibly large source-code listing. If you wrote it it probably would since you don't have the foggiest idea how thinks are implemented in Turing Machines and think instead in terms of C. >> 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. >> > > I don't see how it could do any counter-loop because it would have to > undo all the tape heads move just to look as the counter. > > If it can't do a counter-loop this seems to only leave moving the tape > head to the right in one million sequential steps. As I've suggested many, many, times, the best way to learn how this is done is to look at *actual* Turing Machines. Look at the UTM examples I provided you. When a TM is simulated in those UTMs, the tape head must *constantly* moving back and forth between various places on the tape which are separated by very large distances. It manages this without loop counters and without an "in-feasibly large source-code listing". The UTMs description is only a single page long. 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 16:18 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <8NydndkJ5f--DK_8nZ2dnUU7-e_NnZ2d@giganews.com> |
| In reply to | #38764 |
On 9/3/2021 3:58 PM, André G. Isaak wrote: > On 2021-09-03 14:31, olcott wrote: >> On 9/3/2021 3:24 PM, André G. Isaak wrote: >>> 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. >>> >> >> It would require an in-feasibly large source-code listing. > > If you wrote it it probably would since you don't have the foggiest idea > how thinks are implemented in Turing Machines and think instead in terms > of C. > >>> 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. >>> >> >> I don't see how it could do any counter-loop because it would have to >> undo all the tape heads move just to look as the counter. > > >> If it can't do a counter-loop this seems to only leave moving the tape >> head to the right in one million sequential steps. > > As I've suggested many, many, times, the best way to learn how this is > done is to look at *actual* Turing Machines. Look at the UTM examples I > provided you. When a TM is simulated in those UTMs, the tape head must > *constantly* moving back and forth between various places on the tape > which are separated by very large distances. It manages this without > loop counters and without an "in-feasibly large source-code listing". > This link? What page? https://www.sciencedirect.com/science/article/pii/S0304397596000771?via%3Dihub Until I know a thing is feasible I can't afford to spend any time on it. > The UTMs description is only a single page long. > > André > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-03 17:43 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <NFwYI.48834$o45.22767@fx46.iad> |
| In reply to | #38767 |
On 9/3/21 5:18 PM, olcott wrote: > On 9/3/2021 3:58 PM, André G. Isaak wrote: >> On 2021-09-03 14:31, olcott wrote: >>> On 9/3/2021 3:24 PM, André G. Isaak wrote: >>>> 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. >>>> >>> >>> It would require an in-feasibly large source-code listing. >> >> If you wrote it it probably would since you don't have the foggiest >> idea how thinks are implemented in Turing Machines and think instead >> in terms of C. >> >>>> 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. >>>> >>> >>> I don't see how it could do any counter-loop because it would have to >>> undo all the tape heads move just to look as the counter. >> > >>> If it can't do a counter-loop this seems to only leave moving the >>> tape head to the right in one million sequential steps. >> >> As I've suggested many, many, times, the best way to learn how this is >> done is to look at *actual* Turing Machines. Look at the UTM examples >> I provided you. When a TM is simulated in those UTMs, the tape head >> must *constantly* moving back and forth between various places on the >> tape which are separated by very large distances. It manages this >> without loop counters and without an "in-feasibly large source-code >> listing". >> > > This link? What page? > https://www.sciencedirect.com/science/article/pii/S0304397596000771?via%3Dihub > > > Until I know a thing is feasible I can't afford to spend any time on it. Then why are you working on this Halting Problem rebuttal which you should KNOW isn't feasible? It would take just a few minutes to scan the paper to see that it presents several actual working UTMs and instructions on how to convert a Turing Machine into a proper description for it. > >> The UTMs description is only a single page long. >> >> André >> > >
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-03 15:46 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <sgu54f$t7i$1@dont-email.me> |
| In reply to | #38767 |
On 2021-09-03 15:18, olcott wrote: > On 9/3/2021 3:58 PM, André G. Isaak wrote: >> On 2021-09-03 14:31, olcott wrote: >>> On 9/3/2021 3:24 PM, André G. Isaak wrote: >>>> 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. >>>> >>> >>> It would require an in-feasibly large source-code listing. >> >> If you wrote it it probably would since you don't have the foggiest >> idea how thinks are implemented in Turing Machines and think instead >> in terms of C. >> >>>> 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. >>>> >>> >>> I don't see how it could do any counter-loop because it would have to >>> undo all the tape heads move just to look as the counter. >> > >>> If it can't do a counter-loop this seems to only leave moving the >>> tape head to the right in one million sequential steps. >> >> As I've suggested many, many, times, the best way to learn how this is >> done is to look at *actual* Turing Machines. Look at the UTM examples >> I provided you. When a TM is simulated in those UTMs, the tape head >> must *constantly* moving back and forth between various places on the >> tape which are separated by very large distances. It manages this >> without loop counters and without an "in-feasibly large source-code >> listing". >> > > This link? What page? > https://www.sciencedirect.com/science/article/pii/S0304397596000771?via%3Dihub The paper is only 24 pages long. You can't even be bothered to scan through it to find the state transition listings? Hint: The first one begins on page 222. > Until I know a thing is feasible I can't afford to spend any time on it. You figure out that things are feasible by reading about them or spending time on them. 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 17:14 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <m9mdnXRFrvOqA6_8nZ2dnUU7-VHNnZ2d@giganews.com> |
| In reply to | #38773 |
On 9/3/2021 4:46 PM, André G. Isaak wrote: > On 2021-09-03 15:18, olcott wrote: >> On 9/3/2021 3:58 PM, André G. Isaak wrote: >>> On 2021-09-03 14:31, olcott wrote: >>>> On 9/3/2021 3:24 PM, André G. Isaak wrote: >>>>> 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. >>>>> >>>> >>>> It would require an in-feasibly large source-code listing. >>> >>> If you wrote it it probably would since you don't have the foggiest >>> idea how thinks are implemented in Turing Machines and think instead >>> in terms of C. >>> >>>>> 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. >>>>> >>>> >>>> I don't see how it could do any counter-loop because it would have >>>> to undo all the tape heads move just to look as the counter. >>> > >>>> If it can't do a counter-loop this seems to only leave moving the >>>> tape head to the right in one million sequential steps. >>> >>> As I've suggested many, many, times, the best way to learn how this >>> is done is to look at *actual* Turing Machines. Look at the UTM >>> examples I provided you. When a TM is simulated in those UTMs, the >>> tape head must *constantly* moving back and forth between various >>> places on the tape which are separated by very large distances. It >>> manages this without loop counters and without an "in-feasibly large >>> source-code listing". >>> >> >> This link? What page? >> https://www.sciencedirect.com/science/article/pii/S0304397596000771?via%3Dihub > > > The paper is only 24 pages long. You can't even be bothered to scan > through it to find the state transition listings? Hint: The first one > begins on page 222. > I have no idea what some of that mathematical gobbledygook means. The Greek letter with a down arrow could mean too many different things. The actual source-code of the UTM is simple enough if we assume that the first symbol after the current state is the read value and the second symbol is the write value. Then the tape head moves L or R and we transition to the next state. This still provides no clue how to move the tape head 1000 positions without 1000 sequential steps. >> Until I know a thing is feasible I can't afford to spend any time on it. > > You figure out that things are feasible by reading about them or > spending time on them. > > André > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-03 18:46 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <JAxYI.14401$6u6.13524@fx03.iad> |
| In reply to | #38775 |
On 9/3/21 6:14 PM, olcott wrote: > On 9/3/2021 4:46 PM, André G. Isaak wrote: >> On 2021-09-03 15:18, olcott wrote: >>> On 9/3/2021 3:58 PM, André G. Isaak wrote: >>>> On 2021-09-03 14:31, olcott wrote: >>>>> On 9/3/2021 3:24 PM, André G. Isaak wrote: >>>>>> 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. >>>>>> >>>>> >>>>> It would require an in-feasibly large source-code listing. >>>> >>>> If you wrote it it probably would since you don't have the foggiest >>>> idea how thinks are implemented in Turing Machines and think instead >>>> in terms of C. >>>> >>>>>> 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. >>>>>> >>>>> >>>>> I don't see how it could do any counter-loop because it would have >>>>> to undo all the tape heads move just to look as the counter. >>>> > >>>>> If it can't do a counter-loop this seems to only leave moving the >>>>> tape head to the right in one million sequential steps. >>>> >>>> As I've suggested many, many, times, the best way to learn how this >>>> is done is to look at *actual* Turing Machines. Look at the UTM >>>> examples I provided you. When a TM is simulated in those UTMs, the >>>> tape head must *constantly* moving back and forth between various >>>> places on the tape which are separated by very large distances. It >>>> manages this without loop counters and without an "in-feasibly large >>>> source-code listing". >>>> >>> >>> This link? What page? >>> https://www.sciencedirect.com/science/article/pii/S0304397596000771?via%3Dihub >> >> >> >> The paper is only 24 pages long. You can't even be bothered to scan >> through it to find the state transition listings? Hint: The first one >> begins on page 222. >> > > I have no idea what some of that mathematical gobbledygook means. > The Greek letter with a down arrow could mean too many different things. Problem just some basics of logic that you haven't bothered to learn. > > The actual source-code of the UTM is simple enough if we assume that the > first symbol after the current state is the read value and the second > symbol is the write value. Then the tape head moves L or R and we > transition to the next state. > > This still provides no clue how to move the tape head 1000 positions > without 1000 sequential steps. Again, why do you want to do that. Yes, the quickest way to move 1000 positions is just use 1000 states to do so, but I know of know practical case where you would want to do so. The 'shorter' methods that were being talked about would execute in more time (much more) but with fewer states (much fewer). You will notice that these UTMs definitely don't need to do such a strange thing. Maybe you should study how those machines works to understand how you write real Turing Machines. > >>> Until I know a thing is feasible I can't afford to spend any time on it. >> >> You figure out that things are feasible by reading about them or >> spending time on them. >> >> André >> > > >
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-03 17:00 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <sgu9ef$pqv$1@dont-email.me> |
| In reply to | #38775 |
On 2021-09-03 16:14, olcott wrote: > On 9/3/2021 4:46 PM, André G. Isaak wrote: >> On 2021-09-03 15:18, olcott wrote: >>> On 9/3/2021 3:58 PM, André G. Isaak wrote: >>>> On 2021-09-03 14:31, olcott wrote: >>>>> On 9/3/2021 3:24 PM, André G. Isaak wrote: >>>>>> 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. >>>>>> >>>>> >>>>> It would require an in-feasibly large source-code listing. >>>> >>>> If you wrote it it probably would since you don't have the foggiest >>>> idea how thinks are implemented in Turing Machines and think instead >>>> in terms of C. >>>> >>>>>> 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. >>>>>> >>>>> >>>>> I don't see how it could do any counter-loop because it would have >>>>> to undo all the tape heads move just to look as the counter. >>>> > >>>>> If it can't do a counter-loop this seems to only leave moving the >>>>> tape head to the right in one million sequential steps. >>>> >>>> As I've suggested many, many, times, the best way to learn how this >>>> is done is to look at *actual* Turing Machines. Look at the UTM >>>> examples I provided you. When a TM is simulated in those UTMs, the >>>> tape head must *constantly* moving back and forth between various >>>> places on the tape which are separated by very large distances. It >>>> manages this without loop counters and without an "in-feasibly large >>>> source-code listing". >>>> >>> >>> This link? What page? >>> https://www.sciencedirect.com/science/article/pii/S0304397596000771?via%3Dihub >> >> >> >> The paper is only 24 pages long. You can't even be bothered to scan >> through it to find the state transition listings? Hint: The first one >> begins on page 222. >> > > I have no idea what some of that mathematical gobbledygook means. Then you know how people feel when they try to read your feeble attempts at formalism. > The Greek letter with a down arrow could mean too many different things. The greek letter (which most people simply call beta) with a down arrow is the author's way of telling you that you should probably start reading the paper from the beginning rather than just jump to the descriptions of the UTMs. > The actual source-code of the UTM is simple enough if we assume that the > first symbol after the current state is the read value and the second > symbol is the write value. Then the tape head moves L or R and we > transition to the next state. > > This still provides no clue how to move the tape head 1000 positions > without 1000 sequential steps. So let's think about this for awhile. (1) On the one hand, you make grandiose claims about what Turing Machines *can* do (decide halting, identify infinite recursion by comparing non-existent addresses etc) even though those things have been shown to be impossible. At the same time, (2) you have absolutely no idea of how Turing Machines perform very simple tasks and assert that it must take 'thousands of pages of code' or that they just can't be done. And when given concrete examples (3) you don't show any interest in trying to figure out how they actually work. Does it not occur to you that (2) and (3) might be a good indicator that you're not qualified to do (1)? 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 18:57 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <Tb-dnRkUMO_LK6_8nZ2dnUU7-QnNnZ2d@giganews.com> |
| In reply to | #38779 |
On 9/3/2021 6:00 PM, André G. Isaak wrote: > On 2021-09-03 16:14, olcott wrote: >> On 9/3/2021 4:46 PM, André G. Isaak wrote: >>> On 2021-09-03 15:18, olcott wrote: >>>> On 9/3/2021 3:58 PM, André G. Isaak wrote: >>>>> On 2021-09-03 14:31, olcott wrote: >>>>>> On 9/3/2021 3:24 PM, André G. Isaak wrote: >>>>>>> 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. >>>>>>> >>>>>> >>>>>> It would require an in-feasibly large source-code listing. >>>>> >>>>> If you wrote it it probably would since you don't have the foggiest >>>>> idea how thinks are implemented in Turing Machines and think >>>>> instead in terms of C. >>>>> >>>>>>> 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. >>>>>>> >>>>>> >>>>>> I don't see how it could do any counter-loop because it would have >>>>>> to undo all the tape heads move just to look as the counter. >>>>> > >>>>>> If it can't do a counter-loop this seems to only leave moving the >>>>>> tape head to the right in one million sequential steps. >>>>> >>>>> As I've suggested many, many, times, the best way to learn how this >>>>> is done is to look at *actual* Turing Machines. Look at the UTM >>>>> examples I provided you. When a TM is simulated in those UTMs, the >>>>> tape head must *constantly* moving back and forth between various >>>>> places on the tape which are separated by very large distances. It >>>>> manages this without loop counters and without an "in-feasibly >>>>> large source-code listing". >>>>> >>>> >>>> This link? What page? >>>> https://www.sciencedirect.com/science/article/pii/S0304397596000771?via%3Dihub >>> >>> >>> >>> >>> The paper is only 24 pages long. You can't even be bothered to scan >>> through it to find the state transition listings? Hint: The first one >>> begins on page 222. >>> >> >> I have no idea what some of that mathematical gobbledygook means. > > Then you know how people feel when they try to read your feeble attempts > at formalism. > >> The Greek letter with a down arrow could mean too many different things. > > The greek letter (which most people simply call beta) with a down arrow > is the author's way of telling you that you should probably start > reading the paper from the beginning rather than just jump to the > descriptions of the UTMs. > >> The actual source-code of the UTM is simple enough if we assume that >> the first symbol after the current state is the read value and the >> second symbol is the write value. Then the tape head moves L or R and >> we transition to the next state. >> >> This still provides no clue how to move the tape head 1000 positions >> without 1000 sequential steps. > > So let's think about this for awhile. (1) On the one hand, you make > grandiose claims about what Turing Machines *can* do (decide halting, > identify infinite recursion by comparing non-existent addresses etc) > even though those things have been shown to be impossible. > > At the same time, (2) you have absolutely no idea of how Turing Machines > perform very simple tasks and assert that it must take 'thousands of > pages of code' or that they just can't be done. > > And when given concrete examples (3) you don't show any interest in > trying to figure out how they actually work. > > Does it not occur to you that (2) and (3) might be a good indicator that > you're not qualified to do (1)? > > André > That you claim a TM can move its tape head 1000 positions with much less than 1000 lines of code is worth looking into. It might be more efficient for me to examine the example TM machines posted here. http://www.lns.mit.edu/~dsw/turing/turing.html -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2021-09-03 17:45 -0600 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <sguc2v$7ft$1@dont-email.me> |
| In reply to | #38767 |
On 9/3/2021 3:18 PM, olcott wrote: <SNIP> > Until I know a thing is feasible I can't afford to spend any time on it. I think it's 17 years by "published" accounts of your wasted life. This is the most absurd thing you have ever said. A new record stupidity!!! Wow. You have spent virtually the entire 21st Century to date on unfeasible crap and I do mean crap. If you can last another three years, it will be two decades total in meaningless non-mental masturbation. Just summon up your grittiness and determination to not allow any fact what so ever to penetrate that useless bump you think is a brain and you will cross the finish line in 2020 with that stupid smile we can all visualize. Hat's off to the Alfred E. Newman heir apparent. I wonder if it might be possible to tailor a Darwin award for you if you don't see the dawn of 2020. Your idee fixe has certainly removed your seed from the gene pool. (Not a confirmed fact but a good bet.) It sees like you are headed for awards (posthumously or otherwise) no matter what happens from here on out! You wont publish however. That would be ridiculous. -- Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-03 22:36 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <87lf4ds5nm.fsf@bsb.me.uk> |
| In reply to | #38758 |
André G. Isaak <agisaak@gm.invalid> writes: > 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. Every now and then PO comes out with something that makes my jaw drop! I knew he didn't know how a UTM works but it seems he has no idea about even the simplest TMs. But this made me want to be teaching again. It would make a good class exercise to write the smallest TM you can that, given a blank tape, halts with the tape position 1 million places to the right. There could be a nice target to aim for: "can you beat the all-time winner of size X?". -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 17:25 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <87-dnVbaZ55FPa_8nZ2dnUU7-NmdnZ2d@giganews.com> |
| In reply to | #38770 |
On 9/3/2021 4:36 PM, Ben Bacarisse wrote: > André G. Isaak <agisaak@gm.invalid> writes: > >> 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. > > Every now and then PO comes out with something that makes my jaw drop! > I knew he didn't know how a UTM works but it seems he has no idea about > even the simplest TMs. > > But this made me want to be teaching again. It would make a good class > exercise to write the smallest TM you can that, given a blank tape, > halts with the tape position 1 million places to the right. There could > be a nice target to aim for: "can you beat the all-time winner of size > X?". > It can't check a counter variable because this resets the tape head position. -- 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-04 00:02 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <87a6kts1no.fsf@bsb.me.uk> |
| In reply to | #38776 |
olcott <NoOne@NoWhere.com> writes: > On 9/3/2021 4:36 PM, Ben Bacarisse wrote: >> André G. Isaak <agisaak@gm.invalid> writes: >> >>> On 2021-09-03 14:01, olcott wrote: >>>> 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. >> >> Every now and then PO comes out with something that makes my jaw drop! >> I knew he didn't know how a UTM works but it seems he has no idea about >> even the simplest TMs. >> >> But this made me want to be teaching again. It would make a good class >> exercise to write the smallest TM you can that, given a blank tape, >> halts with the tape position 1 million places to the right. There could >> be a nice target to aim for: "can you beat the all-time winner of size >> X?". > > It can't check a counter variable because this resets the tape head > position. "It" can't "check a counter variable" because TM's don't have variables. Have you considered reading a book about computability? -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 19:03 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <ToidnYbcuvt6Kq_8nZ2dnUU7-U_NnZ2d@giganews.com> |
| In reply to | #38780 |
On 9/3/2021 6:02 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/3/2021 4:36 PM, Ben Bacarisse wrote: >>> André G. Isaak <agisaak@gm.invalid> writes: >>> >>>> On 2021-09-03 14:01, olcott wrote: > >>>>> 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. >>> >>> Every now and then PO comes out with something that makes my jaw drop! >>> I knew he didn't know how a UTM works but it seems he has no idea about >>> even the simplest TMs. >>> >>> But this made me want to be teaching again. It would make a good class >>> exercise to write the smallest TM you can that, given a blank tape, >>> halts with the tape position 1 million places to the right. There could >>> be a nice target to aim for: "can you beat the all-time winner of size >>> X?". >> >> It can't check a counter variable because this resets the tape head >> position. > > "It" can't "check a counter variable" because TM's don't have variables. > Have you considered reading a book about computability? > No actual machine has any actual variables they all only have memory addresses that are set aside for a particular purpose. None-the-less it seems infeasible that a TM could set aside a tape location to be used as a counter for its repetitive movement of the tape head. I have avoided TM's almost entirely on the basis of their lack of RAM. If higher level abstractions that are the functional equivalent to RAM access can be mapped to TMs then we can write higher level code that maps to the TM code. -- 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-04 01:20 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <87y28dqjhs.fsf@bsb.me.uk> |
| In reply to | #38784 |
olcott <NoOne@NoWhere.com> writes: > On 9/3/2021 6:02 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/3/2021 4:36 PM, Ben Bacarisse wrote: >>>> André G. Isaak <agisaak@gm.invalid> writes: >>>> >>>>> On 2021-09-03 14:01, olcott wrote: >> >>>>>> 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. >>>> >>>> Every now and then PO comes out with something that makes my jaw drop! >>>> I knew he didn't know how a UTM works but it seems he has no idea about >>>> even the simplest TMs. >>>> >>>> But this made me want to be teaching again. It would make a good class >>>> exercise to write the smallest TM you can that, given a blank tape, >>>> halts with the tape position 1 million places to the right. There could >>>> be a nice target to aim for: "can you beat the all-time winner of size >>>> X?". >>> >>> It can't check a counter variable because this resets the tape head >>> position. >> >> "It" can't "check a counter variable" because TM's don't have variables. >> Have you considered reading a book about computability? > > No actual machine has any actual variables they all only have memory > addresses that are set aside for a particular purpose. None-the-less > it seems infeasible that a TM could set aside a tape location to be > used as a counter for its repetitive movement of the tape head. I'm not sure what the point of these remarks is. What you don't know about TMs is a big subject but I don't think it's worth exploring. > I have avoided TM's almost entirely on the basis of their lack of RAM. So why do you keep talking about them? Just admit that you have nothing to say about Turing machine halting, and I'll stop pointing out your errors. But if you write about TMs, be prepared to be wrong more often that right. > If higher level abstractions that are the functional equivalent to RAM > access can be mapped to TMs then we can write higher level code that > maps to the TM code. There are many high-level models of computation. They all have halting their own theorems. The lambda calculus is a good one, with the advantage that there direct implementations (subsets of Lisp and most functional languages). Your "model" (x86 code without IO) is not even Turing complete. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 19:27 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <jsednXiD0OrnIK_8nZ2dnUU7-T2dnZ2d@giganews.com> |
| In reply to | #38787 |
On 9/3/2021 7:20 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/3/2021 6:02 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/3/2021 4:36 PM, Ben Bacarisse wrote: >>>>> André G. Isaak <agisaak@gm.invalid> writes: >>>>> >>>>>> On 2021-09-03 14:01, olcott wrote: >>> >>>>>>> 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. >>>>> >>>>> Every now and then PO comes out with something that makes my jaw drop! >>>>> I knew he didn't know how a UTM works but it seems he has no idea about >>>>> even the simplest TMs. >>>>> >>>>> But this made me want to be teaching again. It would make a good class >>>>> exercise to write the smallest TM you can that, given a blank tape, >>>>> halts with the tape position 1 million places to the right. There could >>>>> be a nice target to aim for: "can you beat the all-time winner of size >>>>> X?". >>>> >>>> It can't check a counter variable because this resets the tape head >>>> position. >>> >>> "It" can't "check a counter variable" because TM's don't have variables. >>> Have you considered reading a book about computability? >> >> No actual machine has any actual variables they all only have memory >> addresses that are set aside for a particular purpose. None-the-less >> it seems infeasible that a TM could set aside a tape location to be >> used as a counter for its repetitive movement of the tape head. > > I'm not sure what the point of these remarks is. What you don't know > about TMs is a big subject but I don't think it's worth exploring. > >> I have avoided TM's almost entirely on the basis of their lack of RAM. > > So why do you keep talking about them? Just admit that you have nothing > to say about Turing machine halting, and I'll stop pointing out your > errors. But if you write about TMs, be prepared to be wrong more often > that right. > The RASP architecture stipulates that I can talk about the halting problem in terms of C/x86. >> If higher level abstractions that are the functional equivalent to RAM >> access can be mapped to TMs then we can write higher level code that >> maps to the TM code. > > There are many high-level models of computation. They all have halting > their own theorems. The lambda calculus is a good one, with the > advantage that there direct implementations (subsets of Lisp and most > functional languages). Your "model" (x86 code without IO) is not even > Turing complete. > -- 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 21:10 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <aIzYI.22797$md6.1948@fx36.iad> |
| In reply to | #38789 |
On 9/3/21 8:27 PM, olcott wrote: > On 9/3/2021 7:20 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/3/2021 6:02 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/3/2021 4:36 PM, Ben Bacarisse wrote: >>>>>> André G. Isaak <agisaak@gm.invalid> writes: >>>>>> >>>>>>> On 2021-09-03 14:01, olcott wrote: >>>> >>>>>>>> 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. >>>>>> >>>>>> Every now and then PO comes out with something that makes my jaw >>>>>> drop! >>>>>> I knew he didn't know how a UTM works but it seems he has no idea >>>>>> about >>>>>> even the simplest TMs. >>>>>> >>>>>> But this made me want to be teaching again. It would make a good >>>>>> class >>>>>> exercise to write the smallest TM you can that, given a blank tape, >>>>>> halts with the tape position 1 million places to the right. There >>>>>> could >>>>>> be a nice target to aim for: "can you beat the all-time winner of >>>>>> size >>>>>> X?". >>>>> >>>>> It can't check a counter variable because this resets the tape head >>>>> position. >>>> >>>> "It" can't "check a counter variable" because TM's don't have >>>> variables. >>>> Have you considered reading a book about computability? >>> >>> No actual machine has any actual variables they all only have memory >>> addresses that are set aside for a particular purpose. None-the-less >>> it seems infeasible that a TM could set aside a tape location to be >>> used as a counter for its repetitive movement of the tape head. >> >> I'm not sure what the point of these remarks is. What you don't know >> about TMs is a big subject but I don't think it's worth exploring. >> >>> I have avoided TM's almost entirely on the basis of their lack of RAM. >> >> So why do you keep talking about them? Just admit that you have nothing >> to say about Turing machine halting, and I'll stop pointing out your >> errors. But if you write about TMs, be prepared to be wrong more often >> that right. >> > > The RASP architecture stipulates that I can talk about the halting > problem in terms of C/x86. You DO understand that the x86 is really not that much like a RASP machine? Now, maybe you could write a C compiler for a RASP machine and reformulate your proof based on a REAL RASP machine. I think there are a few conformance issue with writing a conforming C compiler for a RASP machine, but nothing that should affect what you are trying to do. > >>> If higher level abstractions that are the functional equivalent to RAM >>> access can be mapped to TMs then we can write higher level code that >>> maps to the TM code. >> >> There are many high-level models of computation. They all have halting >> their own theorems. The lambda calculus is a good one, with the >> advantage that there direct implementations (subsets of Lisp and most >> functional languages). Your "model" (x86 code without IO) is not even >> Turing complete. >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-03 20:36 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <4sKdnV3ZENspUK_8nZ2dnUU7-XPNnZ2d@giganews.com> |
| In reply to | #38792 |
On 9/3/2021 8:10 PM, Richard Damon wrote: > On 9/3/21 8:27 PM, olcott wrote: >> On 9/3/2021 7:20 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/3/2021 6:02 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> On 9/3/2021 4:36 PM, Ben Bacarisse wrote: >>>>>>> André G. Isaak <agisaak@gm.invalid> writes: >>>>>>> >>>>>>>> On 2021-09-03 14:01, olcott wrote: >>>>> >>>>>>>>> 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. >>>>>>> >>>>>>> Every now and then PO comes out with something that makes my jaw >>>>>>> drop! >>>>>>> I knew he didn't know how a UTM works but it seems he has no idea >>>>>>> about >>>>>>> even the simplest TMs. >>>>>>> >>>>>>> But this made me want to be teaching again. It would make a good >>>>>>> class >>>>>>> exercise to write the smallest TM you can that, given a blank tape, >>>>>>> halts with the tape position 1 million places to the right. There >>>>>>> could >>>>>>> be a nice target to aim for: "can you beat the all-time winner of >>>>>>> size >>>>>>> X?". >>>>>> >>>>>> It can't check a counter variable because this resets the tape head >>>>>> position. >>>>> >>>>> "It" can't "check a counter variable" because TM's don't have >>>>> variables. >>>>> Have you considered reading a book about computability? >>>> >>>> No actual machine has any actual variables they all only have memory >>>> addresses that are set aside for a particular purpose. None-the-less >>>> it seems infeasible that a TM could set aside a tape location to be >>>> used as a counter for its repetitive movement of the tape head. >>> >>> I'm not sure what the point of these remarks is. What you don't know >>> about TMs is a big subject but I don't think it's worth exploring. >>> >>>> I have avoided TM's almost entirely on the basis of their lack of RAM. >>> >>> So why do you keep talking about them? Just admit that you have nothing >>> to say about Turing machine halting, and I'll stop pointing out your >>> errors. But if you write about TMs, be prepared to be wrong more often >>> that right. >>> >> >> The RASP architecture stipulates that I can talk about the halting >> problem in terms of C/x86. > > You DO understand that the x86 is really not that much like a RASP machine? > https://www.researchgate.net/publication/343838609_The_x86_language_has_Turing_Complete_memory_access > Now, maybe you could write a C compiler for a RASP machine and > reformulate your proof based on a REAL RASP machine. I think there are a > few conformance issue with writing a conforming C compiler for a RASP > machine, but nothing that should affect what you are trying to do. If TMs had even the function equivalent of RAM access it may be possible to write an x86 to TM compiler. > >> >>>> If higher level abstractions that are the functional equivalent to RAM >>>> access can be mapped to TMs then we can write higher level code that >>>> maps to the TM code. >>> >>> There are many high-level models of computation. They all have halting >>> their own theorems. The lambda calculus is a good one, with the >>> advantage that there direct implementations (subsets of Lisp and most >>> functional languages). Your "model" (x86 code without IO) is not even >>> Turing complete. >>> >> >> > -- 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 22:07 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <lxAYI.2686$PE4.361@fx11.iad> |
| In reply to | #38795 |
On 9/3/21 9:36 PM, olcott wrote: > On 9/3/2021 8:10 PM, Richard Damon wrote: >> On 9/3/21 8:27 PM, olcott wrote: >>> On 9/3/2021 7:20 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/3/2021 6:02 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> On 9/3/2021 4:36 PM, Ben Bacarisse wrote: >>>>>>>> André G. Isaak <agisaak@gm.invalid> writes: >>>>>>>> >>>>>>>>> On 2021-09-03 14:01, olcott wrote: >>>>>> >>>>>>>>>> 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. >>>>>>>> >>>>>>>> Every now and then PO comes out with something that makes my jaw >>>>>>>> drop! >>>>>>>> I knew he didn't know how a UTM works but it seems he has no idea >>>>>>>> about >>>>>>>> even the simplest TMs. >>>>>>>> >>>>>>>> But this made me want to be teaching again. It would make a good >>>>>>>> class >>>>>>>> exercise to write the smallest TM you can that, given a blank tape, >>>>>>>> halts with the tape position 1 million places to the right. There >>>>>>>> could >>>>>>>> be a nice target to aim for: "can you beat the all-time winner of >>>>>>>> size >>>>>>>> X?". >>>>>>> >>>>>>> It can't check a counter variable because this resets the tape head >>>>>>> position. >>>>>> >>>>>> "It" can't "check a counter variable" because TM's don't have >>>>>> variables. >>>>>> Have you considered reading a book about computability? >>>>> >>>>> No actual machine has any actual variables they all only have memory >>>>> addresses that are set aside for a particular purpose. None-the-less >>>>> it seems infeasible that a TM could set aside a tape location to be >>>>> used as a counter for its repetitive movement of the tape head. >>>> >>>> I'm not sure what the point of these remarks is. What you don't know >>>> about TMs is a big subject but I don't think it's worth exploring. >>>> >>>>> I have avoided TM's almost entirely on the basis of their lack of RAM. >>>> >>>> So why do you keep talking about them? Just admit that you have >>>> nothing >>>> to say about Turing machine halting, and I'll stop pointing out your >>>> errors. But if you write about TMs, be prepared to be wrong more often >>>> that right. >>>> >>> >>> The RASP architecture stipulates that I can talk about the halting >>> problem in terms of C/x86. >> >> You DO understand that the x86 is really not that much like a RASP >> machine? >> > > https://www.researchgate.net/publication/343838609_The_x86_language_has_Turing_Complete_memory_access > > You realize that the issue isn't so much total memory access, but that the fundamental architecture is different. (Limited address space is a theoretical issue, but the other differences have a big effect well before you reach the address space limit). Also, your method doesn't really work as you burn up you address space with all the thunks needed to get to other pages. x86 is byte addressable, with fixed sized registers. The RASP stores arbitrary values in every memory location. You also realize that RASP is missing a LOT of the dirrect features you proably want to use in x86, like it only has a single register and ALL accesses are to a directly specified address, no indexing, no indirect. RASP also does not have a 'CALL' instruction and no 'stack' directly available (which means your current design of giving each level of execution its own stack can't be used). >> Now, maybe you could write a C compiler for a RASP machine and >> reformulate your proof based on a REAL RASP machine. I think there are a >> few conformance issue with writing a conforming C compiler for a RASP >> machine, but nothing that should affect what you are trying to do. > > If TMs had even the function equivalent of RAM access it may be possible > to write an x86 to TM compiler. > Wrong. It doesn't take RAM access to write an x86 to TM compiler. It is possible (but admittedly probably a lot of work) to built a 'UTM' like machine that takes an x86 program on a tape and runs it. >> >>> >>>>> If higher level abstractions that are the functional equivalent to RAM >>>>> access can be mapped to TMs then we can write higher level code that >>>>> maps to the TM code. >>>> >>>> There are many high-level models of computation. They all have halting >>>> their own theorems. The lambda calculus is a good one, with the >>>> advantage that there direct implementations (subsets of Lisp and most >>>> functional languages). Your "model" (x86 code without IO) is not even >>>> Turing complete. >>>> >>> >>> >> > >
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-04 22:30 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ ignorance ] |
| Message-ID | <87zgssni3z.fsf@bsb.me.uk> |
| In reply to | #38789 |
olcott <NoOne@NoWhere.com> writes: > On 9/3/2021 7:20 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/3/2021 6:02 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/3/2021 4:36 PM, Ben Bacarisse wrote: >>>>>> André G. Isaak <agisaak@gm.invalid> writes: >>>>>> >>>>>>> On 2021-09-03 14:01, olcott wrote: >>>> >>>>>>>> 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. >>>>>> >>>>>> Every now and then PO comes out with something that makes my jaw drop! >>>>>> I knew he didn't know how a UTM works but it seems he has no idea about >>>>>> even the simplest TMs. >>>>>> >>>>>> But this made me want to be teaching again. It would make a good class >>>>>> exercise to write the smallest TM you can that, given a blank tape, >>>>>> halts with the tape position 1 million places to the right. There could >>>>>> be a nice target to aim for: "can you beat the all-time winner of size >>>>>> X?". >>>>> >>>>> It can't check a counter variable because this resets the tape head >>>>> position. >>>> >>>> "It" can't "check a counter variable" because TM's don't have variables. >>>> Have you considered reading a book about computability? >>> >>> No actual machine has any actual variables they all only have memory >>> addresses that are set aside for a particular purpose. None-the-less >>> it seems infeasible that a TM could set aside a tape location to be >>> used as a counter for its repetitive movement of the tape head. >> I'm not sure what the point of these remarks is. What you don't know >> about TMs is a big subject but I don't think it's worth exploring. >> >>> I have avoided TM's almost entirely on the basis of their lack of RAM. >> So why do you keep talking about them? Just admit that you have nothing >> to say about Turing machine halting, and I'll stop pointing out your >> errors. But if you write about TMs, be prepared to be wrong more often >> that right. > > The RASP architecture stipulates that I can talk about the halting > problem in terms of C/x86. No it doesn't. But you can talk about halting in C and in x86 code anyway. Who can stop you? -- Ben.
[toc] | [prev] | [next] | [standalone]
Page 17 of 37 — ← Prev page 1 … 15 16 [17] 18 19 … 37 Next page →
Back to top | Article view | comp.theory
csiph-web