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 36 of 37 — ← Prev page 1 … 34 35 [36] 37 Next page →
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-08 23:48 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <5uf_I.24817$nR3.8671@fx38.iad> |
| In reply to | #39207 |
On 9/8/21 11:39 PM, olcott wrote:
> On 9/8/2021 10:29 PM, Richard Damon wrote:
>> On 9/8/21 10:14 PM, olcott wrote:
>>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 9/8/2021 5:52 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 9/8/2021 3:42 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 9/8/2021 9:58 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/7/2021 9:55 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/7/2021 7:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/7/2021 10:31 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> ... You tell us that H should accept <H^><H^>
>>>>>>>>>>>>>>>>>> and you tell us that the TM at H^.qx is an "exact copy"
>>>>>>>>>>>>>>>>>> of H and you
>>>>>>>>>>>>>>>>>> tell us that H^.qx <H^><H^> |- H^.qn. You tell us
>>>>>>>>>>>>>>>>>> everything we need to
>>>>>>>>>>>>>>>>>> know that you are wrong. The only thing missing is an
>>>>>>>>>>>>>>>>>> apology from you
>>>>>>>>>>>>>>>>>> for ignoring these helpful explanations for so long.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Is there anything here you don't understand? It's not
>>>>>>>>>>>>>>>> hard. Identical
>>>>>>>>>>>>>>>> state transition functions always generate the same
>>>>>>>>>>>>>>>> computational steps
>>>>>>>>>>>>>>>> when presented with the same input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>>>>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When the exact analogy to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>> int main() { H1(P,P); } is examined
>>>>>>>>>>>>>> If your analogy does not match the facts I stated about TMs
>>>>>>>>>>>>>> then it's
>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Identical code with identical inputs must derive identical
>>>>>>>>>>>>> results.
>>>>>>>>>>>>
>>>>>>>>>>>> No. That is obviously not true, except for some very rare
>>>>>>>>>>>> languages
>>>>>>>>>>>> that you probably don't know.
>>>>>>>>>>>
>>>>>>>>>>> At this point I would estimate that your technical competence
>>>>>>>>>>> is much
>>>>>>>>>>> lower that I had assumed. I would ask you to provide a concrete
>>>>>>>>>>> example and would estimate that you would dodge thus
>>>>>>>>>>> sufficiently
>>>>>>>>>>> proving that your technical competence is very likely much
>>>>>>>>>>> lower that
>>>>>>>>>>> I had assumed.
>>>>>>>>>>
>>>>>>>>>> As you know, whether I am right or not has nothing to do with
>>>>>>>>>> either my
>>>>>>>>>> competence or your opinion of it. TMs are not "code". Code can
>>>>>>>>>> do IO,
>>>>>>>>>> use static objects, examine its execution environment and so
>>>>>>>>>> on. A lot
>>>>>>>>>> of x86 code even has access to hardware-generated random
>>>>>>>>>> numbers. You
>>>>>>>>>> know this.
>>>>>>>>>>
>>>>>>>>>> If you want to talk code, stop using the notation for TM
>>>>>>>>>> configurations.
>>>>>>>>>> If you want to talk TMs, you will have to face the fact that you
>>>>>>>>>> are
>>>>>>>>>> wrong.
>>>>>>>>>
>>>>>>>>> So like I said you simply dodged supporting your obviously
>>>>>>>>> incorrect
>>>>>>>>> rebuttal that identical code (sequences of state transitions)
>>>>>>>>> cannot
>>>>>>>>> derive different results from the same input.
>>>>>>>>
>>>>>>>> Code is not a "sequence of state transitions", and TMs don't
>>>>>>>> "derive
>>>>>>>> results" (they accept, reject or fail to halt), but I don't want
>>>>>>>> to get
>>>>>>>> sucked into your bad wording.
>>>>>>>>
>>>>>>>> The state transition function of H and that at H^.qx are the same
>>>>>>>> because one TM is an exact copy of the other (your words). The
>>>>>>>> "inputs"
>>>>>>>> (what you should call the tape) and the position of the tape
>>>>>>>> head are
>>>>>>>> also the same. The computations must evolve along exactly the same
>>>>>>>> lines.
>>>>>>>
>>>>>>> This would seem intuitive yet false.
>>>>>>
>>>>>> Its a fact.
>>>>>>
>>>>>>> If we look at it at the very high level of abstraction we can
>>>>>>> comprehend that simulating halt decider H need not abort the
>>>>>>> simulation of its input because the simulating halt decider at Ĥ.qx
>>>>>>> does abort the simulation of its input.
>>>>>>
>>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly the
>>>>>> same
>>>>>> steps when presented with the same tape contents. H must
>>>>>> transition to
>>>>>> qn because H^.qx <H^><H^> does.
>>>>>
>>>>> When one machine is called with an input that refers to its own
>>>>> machine description and another machine is called with an input that
>>>>> does not refer to its own machine description then the two
>>>>> computations are not the same even if their machine descriptions may
>>>>> be otherwise identical.
>>>>
>>>> You are confused. Of course the computations you describe are
>>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but
>>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you
>>>> refuse
>>>> to accept anyway).
>>>>
>>>
>>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace
>>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩
>>> ???
>>
>> Right, and H^ going to H^.qn means that H^ halted, as that is a halting
>> state of H^.
>>
>> THe fact that to H, that state indicated that it thinks its input is
>> non-halting doesn't change the meaning of the state to H^.
>>
>
> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
In that place I didn't say it did. I said that H^ halted, so H <H^><H^>
SHOULD have gone to qy but went to qn, which shows that it was in error.
>
> Your insight that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn seems to indicate an
> inconsistent system was helpful, yet untrue.
What is untrue. You have two machines which you claim to be the same
that give different results, both 'correct', for the same input.
That is the classic definition of Inconsistency.
If <H^> <H^> can both encode a Halting and a Non-Halting Computatation,
the system IS inconsistent.
>
> It is definitely an inconsistency, yet not because the system is
> inconsistent.
>
> int main()
> {
> if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
> OutputString("Pathological self-reference error!");
> }
>
> The above decidability decider correctly rejects the input.
>
>
>> Is THAT your confusion,
>>
>>>
>>> In simpler terms you can't understand that a UTM can examine the
>>> execution trace of its simulated TM?
>>
>> Yes, a UTM can examine it trace, but a real UTM won't stop until the
>> machine it is simulating does, no matter how sure it is that it won't.
>>
>> The problem is when H uses this analysis, and uses the FALSE assumption
>> that other copies of H will act only as UTM, and not switch out of that
>> mode leter and also abort their simulation, that cause H to get the
>> wrong answer.
>>
>> H (like you) used UNSOUND Logic, and got the wrong answer.
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-08 23:08 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <R6udnftE2LZEFaT8nZ2dnUU7-YWdnZ2d@giganews.com> |
| In reply to | #39208 |
On 9/8/2021 10:48 PM, Richard Damon wrote:
> On 9/8/21 11:39 PM, olcott wrote:
>> On 9/8/2021 10:29 PM, Richard Damon wrote:
>>> On 9/8/21 10:14 PM, olcott wrote:
>>>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 9/8/2021 5:52 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 9/8/2021 3:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 9/8/2021 9:58 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/7/2021 9:55 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/7/2021 7:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/7/2021 10:31 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ... You tell us that H should accept <H^><H^>
>>>>>>>>>>>>>>>>>>> and you tell us that the TM at H^.qx is an "exact copy"
>>>>>>>>>>>>>>>>>>> of H and you
>>>>>>>>>>>>>>>>>>> tell us that H^.qx <H^><H^> |- H^.qn. You tell us
>>>>>>>>>>>>>>>>>>> everything we need to
>>>>>>>>>>>>>>>>>>> know that you are wrong. The only thing missing is an
>>>>>>>>>>>>>>>>>>> apology from you
>>>>>>>>>>>>>>>>>>> for ignoring these helpful explanations for so long.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Is there anything here you don't understand? It's not
>>>>>>>>>>>>>>>>> hard. Identical
>>>>>>>>>>>>>>>>> state transition functions always generate the same
>>>>>>>>>>>>>>>>> computational steps
>>>>>>>>>>>>>>>>> when presented with the same input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>>>>>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When the exact analogy to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>> int main() { H1(P,P); } is examined
>>>>>>>>>>>>>>> If your analogy does not match the facts I stated about TMs
>>>>>>>>>>>>>>> then it's
>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Identical code with identical inputs must derive identical
>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No. That is obviously not true, except for some very rare
>>>>>>>>>>>>> languages
>>>>>>>>>>>>> that you probably don't know.
>>>>>>>>>>>>
>>>>>>>>>>>> At this point I would estimate that your technical competence
>>>>>>>>>>>> is much
>>>>>>>>>>>> lower that I had assumed. I would ask you to provide a concrete
>>>>>>>>>>>> example and would estimate that you would dodge thus
>>>>>>>>>>>> sufficiently
>>>>>>>>>>>> proving that your technical competence is very likely much
>>>>>>>>>>>> lower that
>>>>>>>>>>>> I had assumed.
>>>>>>>>>>>
>>>>>>>>>>> As you know, whether I am right or not has nothing to do with
>>>>>>>>>>> either my
>>>>>>>>>>> competence or your opinion of it. TMs are not "code". Code can
>>>>>>>>>>> do IO,
>>>>>>>>>>> use static objects, examine its execution environment and so
>>>>>>>>>>> on. A lot
>>>>>>>>>>> of x86 code even has access to hardware-generated random
>>>>>>>>>>> numbers. You
>>>>>>>>>>> know this.
>>>>>>>>>>>
>>>>>>>>>>> If you want to talk code, stop using the notation for TM
>>>>>>>>>>> configurations.
>>>>>>>>>>> If you want to talk TMs, you will have to face the fact that you
>>>>>>>>>>> are
>>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>>> So like I said you simply dodged supporting your obviously
>>>>>>>>>> incorrect
>>>>>>>>>> rebuttal that identical code (sequences of state transitions)
>>>>>>>>>> cannot
>>>>>>>>>> derive different results from the same input.
>>>>>>>>>
>>>>>>>>> Code is not a "sequence of state transitions", and TMs don't
>>>>>>>>> "derive
>>>>>>>>> results" (they accept, reject or fail to halt), but I don't want
>>>>>>>>> to get
>>>>>>>>> sucked into your bad wording.
>>>>>>>>>
>>>>>>>>> The state transition function of H and that at H^.qx are the same
>>>>>>>>> because one TM is an exact copy of the other (your words). The
>>>>>>>>> "inputs"
>>>>>>>>> (what you should call the tape) and the position of the tape
>>>>>>>>> head are
>>>>>>>>> also the same. The computations must evolve along exactly the same
>>>>>>>>> lines.
>>>>>>>>
>>>>>>>> This would seem intuitive yet false.
>>>>>>>
>>>>>>> Its a fact.
>>>>>>>
>>>>>>>> If we look at it at the very high level of abstraction we can
>>>>>>>> comprehend that simulating halt decider H need not abort the
>>>>>>>> simulation of its input because the simulating halt decider at Ĥ.qx
>>>>>>>> does abort the simulation of its input.
>>>>>>>
>>>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly the
>>>>>>> same
>>>>>>> steps when presented with the same tape contents. H must
>>>>>>> transition to
>>>>>>> qn because H^.qx <H^><H^> does.
>>>>>>
>>>>>> When one machine is called with an input that refers to its own
>>>>>> machine description and another machine is called with an input that
>>>>>> does not refer to its own machine description then the two
>>>>>> computations are not the same even if their machine descriptions may
>>>>>> be otherwise identical.
>>>>>
>>>>> You are confused. Of course the computations you describe are
>>>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but
>>>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you
>>>>> refuse
>>>>> to accept anyway).
>>>>>
>>>>
>>>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace
>>>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> ???
>>>
>>> Right, and H^ going to H^.qn means that H^ halted, as that is a halting
>>> state of H^.
>>>
>>> THe fact that to H, that state indicated that it thinks its input is
>>> non-halting doesn't change the meaning of the state to H^.
>>>
>>
>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>
> In that place I didn't say it did. I said that H^ halted, so H <H^><H^>
> SHOULD have gone to qy but went to qn, which shows that it was in error.
>
>>
>> Your insight that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn seems to indicate an
>> inconsistent system was helpful, yet untrue.
>
> What is untrue. You have two machines which you claim to be the same
> that give different results, both 'correct', for the same input.
>
> That is the classic definition of Inconsistency.
>
> If <H^> <H^> can both encode a Halting and a Non-Halting Computatation,
> the system IS inconsistent.
>
It is definitely an inconsistency, yet not because the system is
inconsistent.
int main()
{
if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
OutputString("Pathological self-reference error!");
}
The above decidability decider correctly rejects the input
>>
>>
>>> Is THAT your confusion,
>>>
>>>>
>>>> In simpler terms you can't understand that a UTM can examine the
>>>> execution trace of its simulated TM?
>>>
>>> Yes, a UTM can examine it trace, but a real UTM won't stop until the
>>> machine it is simulating does, no matter how sure it is that it won't.
>>>
>>> The problem is when H uses this analysis, and uses the FALSE assumption
>>> that other copies of H will act only as UTM, and not switch out of that
>>> mode leter and also abort their simulation, that cause H to get the
>>> wrong answer.
>>>
>>> H (like you) used UNSOUND Logic, and got the wrong answer.
>>>
>>
>>
>
--
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-09 07:09 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <hXl_I.31492$GD7.203@fx23.iad> |
| In reply to | #39210 |
On 9/9/21 12:08 AM, olcott wrote:
> On 9/8/2021 10:48 PM, Richard Damon wrote:
>> On 9/8/21 11:39 PM, olcott wrote:
>>> On 9/8/2021 10:29 PM, Richard Damon wrote:
>>>> On 9/8/21 10:14 PM, olcott wrote:
>>>>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 9/8/2021 5:52 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 9/8/2021 3:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/8/2021 9:58 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/7/2021 9:55 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/7/2021 7:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 9/7/2021 10:31 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> ... You tell us that H should accept <H^><H^>
>>>>>>>>>>>>>>>>>>>> and you tell us that the TM at H^.qx is an "exact copy"
>>>>>>>>>>>>>>>>>>>> of H and you
>>>>>>>>>>>>>>>>>>>> tell us that H^.qx <H^><H^> |- H^.qn. You tell us
>>>>>>>>>>>>>>>>>>>> everything we need to
>>>>>>>>>>>>>>>>>>>> know that you are wrong. The only thing missing is an
>>>>>>>>>>>>>>>>>>>> apology from you
>>>>>>>>>>>>>>>>>>>> for ignoring these helpful explanations for so long.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Is there anything here you don't understand? It's not
>>>>>>>>>>>>>>>>>> hard. Identical
>>>>>>>>>>>>>>>>>> state transition functions always generate the same
>>>>>>>>>>>>>>>>>> computational steps
>>>>>>>>>>>>>>>>>> when presented with the same input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>>>>>>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When the exact analogy to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> int main() { H1(P,P); } is examined
>>>>>>>>>>>>>>>> If your analogy does not match the facts I stated about TMs
>>>>>>>>>>>>>>>> then it's
>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Identical code with identical inputs must derive identical
>>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No. That is obviously not true, except for some very rare
>>>>>>>>>>>>>> languages
>>>>>>>>>>>>>> that you probably don't know.
>>>>>>>>>>>>>
>>>>>>>>>>>>> At this point I would estimate that your technical competence
>>>>>>>>>>>>> is much
>>>>>>>>>>>>> lower that I had assumed. I would ask you to provide a
>>>>>>>>>>>>> concrete
>>>>>>>>>>>>> example and would estimate that you would dodge thus
>>>>>>>>>>>>> sufficiently
>>>>>>>>>>>>> proving that your technical competence is very likely much
>>>>>>>>>>>>> lower that
>>>>>>>>>>>>> I had assumed.
>>>>>>>>>>>>
>>>>>>>>>>>> As you know, whether I am right or not has nothing to do with
>>>>>>>>>>>> either my
>>>>>>>>>>>> competence or your opinion of it. TMs are not "code". Code
>>>>>>>>>>>> can
>>>>>>>>>>>> do IO,
>>>>>>>>>>>> use static objects, examine its execution environment and so
>>>>>>>>>>>> on. A lot
>>>>>>>>>>>> of x86 code even has access to hardware-generated random
>>>>>>>>>>>> numbers. You
>>>>>>>>>>>> know this.
>>>>>>>>>>>>
>>>>>>>>>>>> If you want to talk code, stop using the notation for TM
>>>>>>>>>>>> configurations.
>>>>>>>>>>>> If you want to talk TMs, you will have to face the fact that
>>>>>>>>>>>> you
>>>>>>>>>>>> are
>>>>>>>>>>>> wrong.
>>>>>>>>>>>
>>>>>>>>>>> So like I said you simply dodged supporting your obviously
>>>>>>>>>>> incorrect
>>>>>>>>>>> rebuttal that identical code (sequences of state transitions)
>>>>>>>>>>> cannot
>>>>>>>>>>> derive different results from the same input.
>>>>>>>>>>
>>>>>>>>>> Code is not a "sequence of state transitions", and TMs don't
>>>>>>>>>> "derive
>>>>>>>>>> results" (they accept, reject or fail to halt), but I don't want
>>>>>>>>>> to get
>>>>>>>>>> sucked into your bad wording.
>>>>>>>>>>
>>>>>>>>>> The state transition function of H and that at H^.qx are the same
>>>>>>>>>> because one TM is an exact copy of the other (your words). The
>>>>>>>>>> "inputs"
>>>>>>>>>> (what you should call the tape) and the position of the tape
>>>>>>>>>> head are
>>>>>>>>>> also the same. The computations must evolve along exactly the
>>>>>>>>>> same
>>>>>>>>>> lines.
>>>>>>>>>
>>>>>>>>> This would seem intuitive yet false.
>>>>>>>>
>>>>>>>> Its a fact.
>>>>>>>>
>>>>>>>>> If we look at it at the very high level of abstraction we can
>>>>>>>>> comprehend that simulating halt decider H need not abort the
>>>>>>>>> simulation of its input because the simulating halt decider at
>>>>>>>>> Ĥ.qx
>>>>>>>>> does abort the simulation of its input.
>>>>>>>>
>>>>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly the
>>>>>>>> same
>>>>>>>> steps when presented with the same tape contents. H must
>>>>>>>> transition to
>>>>>>>> qn because H^.qx <H^><H^> does.
>>>>>>>
>>>>>>> When one machine is called with an input that refers to its own
>>>>>>> machine description and another machine is called with an input that
>>>>>>> does not refer to its own machine description then the two
>>>>>>> computations are not the same even if their machine descriptions may
>>>>>>> be otherwise identical.
>>>>>>
>>>>>> You are confused. Of course the computations you describe are
>>>>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but
>>>>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you
>>>>>> refuse
>>>>>> to accept anyway).
>>>>>>
>>>>>
>>>>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace
>>>>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩
>>>>> ⟨Ĥ⟩
>>>>> ???
>>>>
>>>> Right, and H^ going to H^.qn means that H^ halted, as that is a halting
>>>> state of H^.
>>>>
>>>> THe fact that to H, that state indicated that it thinks its input is
>>>> non-halting doesn't change the meaning of the state to H^.
>>>>
>>>
>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>
>> In that place I didn't say it did. I said that H^ halted, so H <H^><H^>
>> SHOULD have gone to qy but went to qn, which shows that it was in error.
>>
>>>
>>> Your insight that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn seems to indicate an
>>> inconsistent system was helpful, yet untrue.
>>
>> What is untrue. You have two machines which you claim to be the same
>> that give different results, both 'correct', for the same input.
>>
>> That is the classic definition of Inconsistency.
>>
>> If <H^> <H^> can both encode a Halting and a Non-Halting Computatation,
>> the system IS inconsistent.
>>
>
>
> It is definitely an inconsistency, yet not because the system is
> inconsistent.
WRONG. Your logic system has decided that P(P) is both Halting and
Non-Halting which is inconsistent.
Either the system is inconsistent or P isn't a computation but that can
only be if H isn't a Computation and your lied about it being one.
If H isn't a Computation, then nothing you have said matters as H isn't
qualified to be a Halt Decider, so you have just been spouting years of
Hot Air.
>
> int main()
> {
> if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
> OutputString("Pathological self-reference error!");
> }
>
> The above decidability decider correctly rejects the input
So, what is the definition of this Decidability Decider that claims to
be correct?
Or is it just pointing out that your H was WRONG.
>
>>>
>>>
>>>> Is THAT your confusion,
>>>>
>>>>>
>>>>> In simpler terms you can't understand that a UTM can examine the
>>>>> execution trace of its simulated TM?
>>>>
>>>> Yes, a UTM can examine it trace, but a real UTM won't stop until the
>>>> machine it is simulating does, no matter how sure it is that it won't.
>>>>
>>>> The problem is when H uses this analysis, and uses the FALSE assumption
>>>> that other copies of H will act only as UTM, and not switch out of that
>>>> mode leter and also abort their simulation, that cause H to get the
>>>> wrong answer.
>>>>
>>>> H (like you) used UNSOUND Logic, and got the wrong answer.
>>>>
>>>
>>>
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-09 09:18 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <jvqdnYEcS8kuiqf8nZ2dnUU7-Y-dnZ2d@giganews.com> |
| In reply to | #39220 |
On 9/9/2021 6:09 AM, Richard Damon wrote:
> On 9/9/21 12:08 AM, olcott wrote:
>> On 9/8/2021 10:48 PM, Richard Damon wrote:
>>> On 9/8/21 11:39 PM, olcott wrote:
>>>> On 9/8/2021 10:29 PM, Richard Damon wrote:
>>>>> On 9/8/21 10:14 PM, olcott wrote:
>>>>>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 9/8/2021 5:52 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 9/8/2021 3:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/8/2021 9:58 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/7/2021 9:55 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/7/2021 7:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 9/7/2021 10:31 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> ... You tell us that H should accept <H^><H^>
>>>>>>>>>>>>>>>>>>>>> and you tell us that the TM at H^.qx is an "exact copy"
>>>>>>>>>>>>>>>>>>>>> of H and you
>>>>>>>>>>>>>>>>>>>>> tell us that H^.qx <H^><H^> |- H^.qn. You tell us
>>>>>>>>>>>>>>>>>>>>> everything we need to
>>>>>>>>>>>>>>>>>>>>> know that you are wrong. The only thing missing is an
>>>>>>>>>>>>>>>>>>>>> apology from you
>>>>>>>>>>>>>>>>>>>>> for ignoring these helpful explanations for so long.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Is there anything here you don't understand? It's not
>>>>>>>>>>>>>>>>>>> hard. Identical
>>>>>>>>>>>>>>>>>>> state transition functions always generate the same
>>>>>>>>>>>>>>>>>>> computational steps
>>>>>>>>>>>>>>>>>>> when presented with the same input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>>>>>>>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When the exact analogy to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> int main() { H1(P,P); } is examined
>>>>>>>>>>>>>>>>> If your analogy does not match the facts I stated about TMs
>>>>>>>>>>>>>>>>> then it's
>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Identical code with identical inputs must derive identical
>>>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No. That is obviously not true, except for some very rare
>>>>>>>>>>>>>>> languages
>>>>>>>>>>>>>>> that you probably don't know.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> At this point I would estimate that your technical competence
>>>>>>>>>>>>>> is much
>>>>>>>>>>>>>> lower that I had assumed. I would ask you to provide a
>>>>>>>>>>>>>> concrete
>>>>>>>>>>>>>> example and would estimate that you would dodge thus
>>>>>>>>>>>>>> sufficiently
>>>>>>>>>>>>>> proving that your technical competence is very likely much
>>>>>>>>>>>>>> lower that
>>>>>>>>>>>>>> I had assumed.
>>>>>>>>>>>>>
>>>>>>>>>>>>> As you know, whether I am right or not has nothing to do with
>>>>>>>>>>>>> either my
>>>>>>>>>>>>> competence or your opinion of it. TMs are not "code". Code
>>>>>>>>>>>>> can
>>>>>>>>>>>>> do IO,
>>>>>>>>>>>>> use static objects, examine its execution environment and so
>>>>>>>>>>>>> on. A lot
>>>>>>>>>>>>> of x86 code even has access to hardware-generated random
>>>>>>>>>>>>> numbers. You
>>>>>>>>>>>>> know this.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you want to talk code, stop using the notation for TM
>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>> If you want to talk TMs, you will have to face the fact that
>>>>>>>>>>>>> you
>>>>>>>>>>>>> are
>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> So like I said you simply dodged supporting your obviously
>>>>>>>>>>>> incorrect
>>>>>>>>>>>> rebuttal that identical code (sequences of state transitions)
>>>>>>>>>>>> cannot
>>>>>>>>>>>> derive different results from the same input.
>>>>>>>>>>>
>>>>>>>>>>> Code is not a "sequence of state transitions", and TMs don't
>>>>>>>>>>> "derive
>>>>>>>>>>> results" (they accept, reject or fail to halt), but I don't want
>>>>>>>>>>> to get
>>>>>>>>>>> sucked into your bad wording.
>>>>>>>>>>>
>>>>>>>>>>> The state transition function of H and that at H^.qx are the same
>>>>>>>>>>> because one TM is an exact copy of the other (your words). The
>>>>>>>>>>> "inputs"
>>>>>>>>>>> (what you should call the tape) and the position of the tape
>>>>>>>>>>> head are
>>>>>>>>>>> also the same. The computations must evolve along exactly the
>>>>>>>>>>> same
>>>>>>>>>>> lines.
>>>>>>>>>>
>>>>>>>>>> This would seem intuitive yet false.
>>>>>>>>>
>>>>>>>>> Its a fact.
>>>>>>>>>
>>>>>>>>>> If we look at it at the very high level of abstraction we can
>>>>>>>>>> comprehend that simulating halt decider H need not abort the
>>>>>>>>>> simulation of its input because the simulating halt decider at
>>>>>>>>>> Ĥ.qx
>>>>>>>>>> does abort the simulation of its input.
>>>>>>>>>
>>>>>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly the
>>>>>>>>> same
>>>>>>>>> steps when presented with the same tape contents. H must
>>>>>>>>> transition to
>>>>>>>>> qn because H^.qx <H^><H^> does.
>>>>>>>>
>>>>>>>> When one machine is called with an input that refers to its own
>>>>>>>> machine description and another machine is called with an input that
>>>>>>>> does not refer to its own machine description then the two
>>>>>>>> computations are not the same even if their machine descriptions may
>>>>>>>> be otherwise identical.
>>>>>>>
>>>>>>> You are confused. Of course the computations you describe are
>>>>>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but
>>>>>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you
>>>>>>> refuse
>>>>>>> to accept anyway).
>>>>>>>
>>>>>>
>>>>>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace
>>>>>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩
>>>>>> ⟨Ĥ⟩
>>>>>> ???
>>>>>
>>>>> Right, and H^ going to H^.qn means that H^ halted, as that is a halting
>>>>> state of H^.
>>>>>
>>>>> THe fact that to H, that state indicated that it thinks its input is
>>>>> non-halting doesn't change the meaning of the state to H^.
>>>>>
>>>>
>>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>>
>>> In that place I didn't say it did. I said that H^ halted, so H <H^><H^>
>>> SHOULD have gone to qy but went to qn, which shows that it was in error.
>>>
>>>>
>>>> Your insight that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn seems to indicate an
>>>> inconsistent system was helpful, yet untrue.
>>>
>>> What is untrue. You have two machines which you claim to be the same
>>> that give different results, both 'correct', for the same input.
>>>
>>> That is the classic definition of Inconsistency.
>>>
>>> If <H^> <H^> can both encode a Halting and a Non-Halting Computatation,
>>> the system IS inconsistent.
>>>
>>
>>
>> It is definitely an inconsistency, yet not because the system is
>> inconsistent.
>
> WRONG. Your logic system has decided that P(P) is both Halting and
> Non-Halting which is inconsistent.
>
> Either the system is inconsistent or P isn't a computation but that can
> only be if H isn't a Computation and your lied about it being one.
>
> If H isn't a Computation, then nothing you have said matters as H isn't
> qualified to be a Halt Decider, so you have just been spouting years of
> Hot Air.
>
>>
>> int main()
>> {
>> if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
>> OutputString("Pathological self-reference error!");
>> }
>>
>> The above decidability decider correctly rejects the input
>
> So, what is the definition of this Decidability Decider that claims to
> be correct?
>
The decidability decider correctly decides that the input has the
pathological self-reference(Olcott 2004) error, thus bad data is the
source of the inconsistency.
> Or is it just pointing out that your H was WRONG.
>
>>
>>>>
>>>>
>>>>> Is THAT your confusion,
>>>>>
>>>>>>
>>>>>> In simpler terms you can't understand that a UTM can examine the
>>>>>> execution trace of its simulated TM?
>>>>>
>>>>> Yes, a UTM can examine it trace, but a real UTM won't stop until the
>>>>> machine it is simulating does, no matter how sure it is that it won't.
>>>>>
>>>>> The problem is when H uses this analysis, and uses the FALSE assumption
>>>>> that other copies of H will act only as UTM, and not switch out of that
>>>>> mode leter and also abort their simulation, that cause H to get the
>>>>> wrong answer.
>>>>>
>>>>> H (like you) used UNSOUND Logic, and got the wrong answer.
>>>>>
>>>>
>>>>
>>>
>>
>>
>
--
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-09 20:53 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <u0y_I.78060$Kv2.17668@fx47.iad> |
| In reply to | #39226 |
On 9/9/21 10:18 AM, olcott wrote:
> On 9/9/2021 6:09 AM, Richard Damon wrote:
>> On 9/9/21 12:08 AM, olcott wrote:
>>> On 9/8/2021 10:48 PM, Richard Damon wrote:
>>>> On 9/8/21 11:39 PM, olcott wrote:
>>>>> On 9/8/2021 10:29 PM, Richard Damon wrote:
>>>>>> On 9/8/21 10:14 PM, olcott wrote:
>>>>>>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 9/8/2021 5:52 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/8/2021 3:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/8/2021 9:58 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/7/2021 9:55 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 9/7/2021 7:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 9/7/2021 10:31 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> ... You tell us that H should accept <H^><H^>
>>>>>>>>>>>>>>>>>>>>>> and you tell us that the TM at H^.qx is an "exact
>>>>>>>>>>>>>>>>>>>>>> copy"
>>>>>>>>>>>>>>>>>>>>>> of H and you
>>>>>>>>>>>>>>>>>>>>>> tell us that H^.qx <H^><H^> |- H^.qn. You tell us
>>>>>>>>>>>>>>>>>>>>>> everything we need to
>>>>>>>>>>>>>>>>>>>>>> know that you are wrong. The only thing missing
>>>>>>>>>>>>>>>>>>>>>> is an
>>>>>>>>>>>>>>>>>>>>>> apology from you
>>>>>>>>>>>>>>>>>>>>>> for ignoring these helpful explanations for so long.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Is there anything here you don't understand? It's not
>>>>>>>>>>>>>>>>>>>> hard. Identical
>>>>>>>>>>>>>>>>>>>> state transition functions always generate the same
>>>>>>>>>>>>>>>>>>>> computational steps
>>>>>>>>>>>>>>>>>>>> when presented with the same input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>>>>>>>>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When the exact analogy to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> int main() { H1(P,P); } is examined
>>>>>>>>>>>>>>>>>> If your analogy does not match the facts I stated
>>>>>>>>>>>>>>>>>> about TMs
>>>>>>>>>>>>>>>>>> then it's
>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Identical code with identical inputs must derive identical
>>>>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No. That is obviously not true, except for some very rare
>>>>>>>>>>>>>>>> languages
>>>>>>>>>>>>>>>> that you probably don't know.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> At this point I would estimate that your technical
>>>>>>>>>>>>>>> competence
>>>>>>>>>>>>>>> is much
>>>>>>>>>>>>>>> lower that I had assumed. I would ask you to provide a
>>>>>>>>>>>>>>> concrete
>>>>>>>>>>>>>>> example and would estimate that you would dodge thus
>>>>>>>>>>>>>>> sufficiently
>>>>>>>>>>>>>>> proving that your technical competence is very likely much
>>>>>>>>>>>>>>> lower that
>>>>>>>>>>>>>>> I had assumed.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> As you know, whether I am right or not has nothing to do with
>>>>>>>>>>>>>> either my
>>>>>>>>>>>>>> competence or your opinion of it. TMs are not "code". Code
>>>>>>>>>>>>>> can
>>>>>>>>>>>>>> do IO,
>>>>>>>>>>>>>> use static objects, examine its execution environment and so
>>>>>>>>>>>>>> on. A lot
>>>>>>>>>>>>>> of x86 code even has access to hardware-generated random
>>>>>>>>>>>>>> numbers. You
>>>>>>>>>>>>>> know this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you want to talk code, stop using the notation for TM
>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>> If you want to talk TMs, you will have to face the fact that
>>>>>>>>>>>>>> you
>>>>>>>>>>>>>> are
>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So like I said you simply dodged supporting your obviously
>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>> rebuttal that identical code (sequences of state transitions)
>>>>>>>>>>>>> cannot
>>>>>>>>>>>>> derive different results from the same input.
>>>>>>>>>>>>
>>>>>>>>>>>> Code is not a "sequence of state transitions", and TMs don't
>>>>>>>>>>>> "derive
>>>>>>>>>>>> results" (they accept, reject or fail to halt), but I don't
>>>>>>>>>>>> want
>>>>>>>>>>>> to get
>>>>>>>>>>>> sucked into your bad wording.
>>>>>>>>>>>>
>>>>>>>>>>>> The state transition function of H and that at H^.qx are the
>>>>>>>>>>>> same
>>>>>>>>>>>> because one TM is an exact copy of the other (your words). The
>>>>>>>>>>>> "inputs"
>>>>>>>>>>>> (what you should call the tape) and the position of the tape
>>>>>>>>>>>> head are
>>>>>>>>>>>> also the same. The computations must evolve along exactly the
>>>>>>>>>>>> same
>>>>>>>>>>>> lines.
>>>>>>>>>>>
>>>>>>>>>>> This would seem intuitive yet false.
>>>>>>>>>>
>>>>>>>>>> Its a fact.
>>>>>>>>>>
>>>>>>>>>>> If we look at it at the very high level of abstraction we can
>>>>>>>>>>> comprehend that simulating halt decider H need not abort the
>>>>>>>>>>> simulation of its input because the simulating halt decider at
>>>>>>>>>>> Ĥ.qx
>>>>>>>>>>> does abort the simulation of its input.
>>>>>>>>>>
>>>>>>>>>> The identical "machines" at H.q0 and H^.qx must perform
>>>>>>>>>> exactly the
>>>>>>>>>> same
>>>>>>>>>> steps when presented with the same tape contents. H must
>>>>>>>>>> transition to
>>>>>>>>>> qn because H^.qx <H^><H^> does.
>>>>>>>>>
>>>>>>>>> When one machine is called with an input that refers to its own
>>>>>>>>> machine description and another machine is called with an input
>>>>>>>>> that
>>>>>>>>> does not refer to its own machine description then the two
>>>>>>>>> computations are not the same even if their machine
>>>>>>>>> descriptions may
>>>>>>>>> be otherwise identical.
>>>>>>>>
>>>>>>>> You are confused. Of course the computations you describe are
>>>>>>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same
>>>>>>>> but
>>>>>>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you
>>>>>>>> refuse
>>>>>>>> to accept anyway).
>>>>>>>>
>>>>>>>
>>>>>>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution
>>>>>>> trace
>>>>>>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩
>>>>>>> ⟨Ĥ⟩
>>>>>>> ???
>>>>>>
>>>>>> Right, and H^ going to H^.qn means that H^ halted, as that is a
>>>>>> halting
>>>>>> state of H^.
>>>>>>
>>>>>> THe fact that to H, that state indicated that it thinks its input is
>>>>>> non-halting doesn't change the meaning of the state to H^.
>>>>>>
>>>>>
>>>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>>>> No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many times.
>>>>
>>>> In that place I didn't say it did. I said that H^ halted, so H <H^><H^>
>>>> SHOULD have gone to qy but went to qn, which shows that it was in
>>>> error.
>>>>
>>>>>
>>>>> Your insight that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn seems to
>>>>> indicate an
>>>>> inconsistent system was helpful, yet untrue.
>>>>
>>>> What is untrue. You have two machines which you claim to be the same
>>>> that give different results, both 'correct', for the same input.
>>>>
>>>> That is the classic definition of Inconsistency.
>>>>
>>>> If <H^> <H^> can both encode a Halting and a Non-Halting Computatation,
>>>> the system IS inconsistent.
>>>>
>>>
>>>
>>> It is definitely an inconsistency, yet not because the system is
>>> inconsistent.
>>
>> WRONG. Your logic system has decided that P(P) is both Halting and
>> Non-Halting which is inconsistent.
>>
>> Either the system is inconsistent or P isn't a computation but that can
>> only be if H isn't a Computation and your lied about it being one.
>>
>> If H isn't a Computation, then nothing you have said matters as H isn't
>> qualified to be a Halt Decider, so you have just been spouting years of
>> Hot Air.
>>
>>>
>>> int main()
>>> {
>>> if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
>>> OutputString("Pathological self-reference error!");
>>> }
>>>
>>> The above decidability decider correctly rejects the input
>>
>> So, what is the definition of this Decidability Decider that claims to
>> be correct?
>>
>
> The decidability decider correctly decides that the input has the
> pathological self-reference(Olcott 2004) error, thus bad data is the
> source of the inconsistency.
>
The Question is Valid, so I don't know what this decidability decider is
actual supposed to be saying. P(P) does HAVE a definite answer, so there
IS a right answer, is this decider just to tell you what machines you
get wrong.
Can you give an actual definition of what the 'Decidability Criteria'
is, other than that two halt deciders give a different answer? All that
says is that one of them must be wrong.
>> Or is it just pointing out that your H was WRONG.
>>
>>>
>>>>>
>>>>>
>>>>>> Is THAT your confusion,
>>>>>>
>>>>>>>
>>>>>>> In simpler terms you can't understand that a UTM can examine the
>>>>>>> execution trace of its simulated TM?
>>>>>>
>>>>>> Yes, a UTM can examine it trace, but a real UTM won't stop until the
>>>>>> machine it is simulating does, no matter how sure it is that it
>>>>>> won't.
>>>>>>
>>>>>> The problem is when H uses this analysis, and uses the FALSE
>>>>>> assumption
>>>>>> that other copies of H will act only as UTM, and not switch out of
>>>>>> that
>>>>>> mode leter and also abort their simulation, that cause H to get the
>>>>>> wrong answer.
>>>>>>
>>>>>> H (like you) used UNSOUND Logic, and got the wrong answer.
>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>>
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-09 12:02 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <874kauau6l.fsf@bsb.me.uk> |
| In reply to | #39191 |
olcott <NoOne@NoWhere.com> writes: > On 9/8/2021 8:54 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>>> If we look at it at the very high level of abstraction we can >>>>> comprehend that simulating halt decider H need not abort the >>>>> simulation of its input because the simulating halt decider at Ĥ.qx >>>>> does abort the simulation of its input. >>>> >>>> The identical "machines" at H.q0 and H^.qx must perform exactly the same >>>> steps when presented with the same tape contents. H must transition to >>>> qn because H^.qx <H^><H^> does. >>> >>> When one machine is called with an input that refers to its own >>> machine description and another machine is called with an input that >>> does not refer to its own machine description then the two >>> computations are not the same even if their machine descriptions may >>> be otherwise identical. >> >> You are confused. Of course the computations you describe are >> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but >> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you refuse >> to accept anyway). > > You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace > of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ > ⟨Ĥ⟩ ??? That H^.qx <H^><H^> transitions to H^.qn has never been in doubt. It's a fact you tell us about a supposed TM that we will never see. But if H^.qx <H^><H^> transitions to H^.qn, then so does H.q0 <H^><H^>. That's all there is to it. Identical (well, technically, isomorphic) state transition functions result in identical behaviour, given identical tape contents. And you have recently "seen the light" and agreed that H should accept the string <H^><H^> and not reject it. If your traces confirm that H^.qx <H^><H^> transitions to H^.qn, then so what? That was never in dispute. But this is only confirmation by analogy. I have seen no execution traces of any TMs. And you don't have any either. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-09 08:47 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <GsSdnRWDo8L9jaf8nZ2dnUU78cfNnZ2d@giganews.com> |
| In reply to | #39217 |
On 9/9/2021 6:02 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/8/2021 8:54 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: > >>>>>> If we look at it at the very high level of abstraction we can >>>>>> comprehend that simulating halt decider H need not abort the >>>>>> simulation of its input because the simulating halt decider at Ĥ.qx >>>>>> does abort the simulation of its input. >>>>> >>>>> The identical "machines" at H.q0 and H^.qx must perform exactly the same >>>>> steps when presented with the same tape contents. H must transition to >>>>> qn because H^.qx <H^><H^> does. >>>> >>>> When one machine is called with an input that refers to its own >>>> machine description and another machine is called with an input that >>>> does not refer to its own machine description then the two >>>> computations are not the same even if their machine descriptions may >>>> be otherwise identical. >>> >>> You are confused. Of course the computations you describe are >>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but >>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you refuse >>> to accept anyway). >> >> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace >> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ >> ⟨Ĥ⟩ ??? > > That H^.qx <H^><H^> transitions to H^.qn has never been in doubt. It's > a fact you tell us about a supposed TM that we will never see. But if > H^.qx <H^><H^> transitions to H^.qn, then so does H.q0 <H^><H^>. You only addressed halt of what I said. (1) Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ (2) This is the part that you ignored The execution trace of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn shows that the input to H ⟨Ĥ⟩ ⟨Ĥ⟩ halts and H can see this execution trace therefore H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy Richard pointed out that this result is inconsistent and he is correct. It is not impossible for a formal system to derive inconsistent results. > That's > all there is to it. Identical (well, technically, isomorphic) state > transition functions result in identical behaviour, given identical tape > contents. And you have recently "seen the light" and agreed that H > should accept the string <H^><H^> and not reject it. > > If your traces confirm that H^.qx <H^><H^> transitions to H^.qn, then so > what? That was never in dispute. But this is only confirmation by > analogy. I have seen no execution traces of any TMs. And you don't > have any either. > -- 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-09 16:18 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <87mtolaibw.fsf@bsb.me.uk> |
| In reply to | #39222 |
olcott <NoOne@NoWhere.com> writes: > On 9/9/2021 6:02 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >> >>>>>>> If we look at it at the very high level of abstraction we can >>>>>>> comprehend that simulating halt decider H need not abort the >>>>>>> simulation of its input because the simulating halt decider at Ĥ.qx >>>>>>> does abort the simulation of its input. >>>>>> >>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly the same >>>>>> steps when presented with the same tape contents. H must transition to >>>>>> qn because H^.qx <H^><H^> does. >>>>> >>>>> When one machine is called with an input that refers to its own >>>>> machine description and another machine is called with an input that >>>>> does not refer to its own machine description then the two >>>>> computations are not the same even if their machine descriptions may >>>>> be otherwise identical. >>>> >>>> You are confused. Of course the computations you describe are >>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but >>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you refuse >>>> to accept anyway). >>> >>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace >>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ >>> ⟨Ĥ⟩ ??? >> >> That H^.qx <H^><H^> transitions to H^.qn has never been in doubt. It's >> a fact you tell us about a supposed TM that we will never see. But if >> H^.qx <H^><H^> transitions to H^.qn, then so does H.q0 <H^><H^>. > > You only addressed halt of what I said. > (1) Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ Right, so the identical Turing machine H does the same on the same input. > (2) This is the part that you ignored > > The execution trace of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn > shows that the input to H ⟨Ĥ⟩ ⟨Ĥ⟩ halts and H can see this execution > trace therefore H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy No. Stating a falsehood does not make it true. There is no possibility that H and the "exact copy" of H embedded in H^ can take different paths through their respective state graphs. It just that simple and, since I can't make it any simpler, if you can't see it by now, I don't think there is any hope that you ever will. But why have you changed your mind about what the correct answer is? You spent months arguing (about your secret C code) that H(H_Hat, H_Hat) == false was correct, and now that I am confirming that (for analogous TM) H does indeed reject <H^><H^> you complain that it is not so. OK, so one is real code that just gets the answer wrong, and the other an imagined TM, but are they not supposed to be analogous? -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-09 10:31 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <MYCdnfZMbLhTtaf8nZ2dnUU7-W_NnZ2d@giganews.com> |
| In reply to | #39228 |
On 9/9/2021 10:18 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/9/2021 6:02 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote: >>>>>>> olcott <NoOne@NoWhere.com> writes: >>> >>>>>>>> If we look at it at the very high level of abstraction we can >>>>>>>> comprehend that simulating halt decider H need not abort the >>>>>>>> simulation of its input because the simulating halt decider at Ĥ.qx >>>>>>>> does abort the simulation of its input. >>>>>>> >>>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly the same >>>>>>> steps when presented with the same tape contents. H must transition to >>>>>>> qn because H^.qx <H^><H^> does. >>>>>> >>>>>> When one machine is called with an input that refers to its own >>>>>> machine description and another machine is called with an input that >>>>>> does not refer to its own machine description then the two >>>>>> computations are not the same even if their machine descriptions may >>>>>> be otherwise identical. >>>>> >>>>> You are confused. Of course the computations you describe are >>>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but >>>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you refuse >>>>> to accept anyway). >>>> >>>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace >>>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ >>>> ⟨Ĥ⟩ ??? >>> >>> That H^.qx <H^><H^> transitions to H^.qn has never been in doubt. It's >>> a fact you tell us about a supposed TM that we will never see. But if >>> H^.qx <H^><H^> transitions to H^.qn, then so does H.q0 <H^><H^>. >> >> You only addressed halt of what I said. >> (1) Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ > > Right, so the identical Turing machine H does the same on the same > input. > >> (2) This is the part that you ignored >> >> The execution trace of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >> shows that the input to H ⟨Ĥ⟩ ⟨Ĥ⟩ halts and H can see this execution >> trace therefore H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy > > No. Stating a falsehood does not make it true. There is no possibility > that H and the "exact copy" of H embedded in H^ can take different paths > through their respective state graphs. Perhaps it is time that we discontinue our dialogue because you lack the mandatory prerequisite knowledge of C/x86 to understand that: It is the case that H(P,P)==0 is correct. It is the case that H1((P,P)==1 is correct. It is the case that this is inconsistent. It is the case that this inconsistency defines a decidability decider that correctly rejects P on the basis that P has the pathological self-reference(Olcott 2004) error. Because you are clueless about the x86 language you would also lack the competence to determine whether or not H(P,P) forms an accurate proxy computation for Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩. > It just that simple and, since I > can't make it any simpler, if you can't see it by now, I don't think > there is any hope that you ever will. > > But why have you changed your mind about what the correct answer is? > You spent months arguing (about your secret C code) that H(H_Hat, H_Hat) > == false was correct, and now that I am confirming that (for analogous > TM) H does indeed reject <H^><H^> you complain that it is not so. OK, > so one is real code that just gets the answer wrong, and the other an > imagined TM, but are they not supposed to be analogous? > -- 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-09 23:29 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <87tuit8jrw.fsf@bsb.me.uk> |
| In reply to | #39230 |
olcott <NoOne@NoWhere.com> writes: > On 9/9/2021 10:18 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/9/2021 6:02 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>>>>>> If we look at it at the very high level of abstraction we can >>>>>>>>> comprehend that simulating halt decider H need not abort the >>>>>>>>> simulation of its input because the simulating halt decider at Ĥ.qx >>>>>>>>> does abort the simulation of its input. >>>>>>>> >>>>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly the same >>>>>>>> steps when presented with the same tape contents. H must transition to >>>>>>>> qn because H^.qx <H^><H^> does. >>>>>>> >>>>>>> When one machine is called with an input that refers to its own >>>>>>> machine description and another machine is called with an input that >>>>>>> does not refer to its own machine description then the two >>>>>>> computations are not the same even if their machine descriptions may >>>>>>> be otherwise identical. >>>>>> >>>>>> You are confused. Of course the computations you describe are >>>>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but >>>>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you refuse >>>>>> to accept anyway). >>>>> >>>>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace >>>>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ >>>>> ⟨Ĥ⟩ ??? >>>> >>>> That H^.qx <H^><H^> transitions to H^.qn has never been in doubt. It's >>>> a fact you tell us about a supposed TM that we will never see. But if >>>> H^.qx <H^><H^> transitions to H^.qn, then so does H.q0 <H^><H^>. >>> >>> You only addressed halt of what I said. >>> (1) Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ >> Right, so the identical Turing machine H does the same on the same >> input. >> >>> (2) This is the part that you ignored >>> >>> The execution trace of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>> shows that the input to H ⟨Ĥ⟩ ⟨Ĥ⟩ halts and H can see this execution >>> trace therefore H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy >> >> No. Stating a falsehood does not make it true. There is no possibility >> that H and the "exact copy" of H embedded in H^ can take different paths >> through their respective state graphs. > > Perhaps it is time that we discontinue our dialogue You can discontinue any time you like. You don't offer any coherent objection to the obvious statement that identical machines behave the same when given identical inputs, so just not replying would seem to be an excellent alternative. > because > you lack the mandatory prerequisite knowledge of C/x86 to > understand that: I am pointing out the mistakes you are making about Turing machines. The formal lines you like to post are about Turing machines and their tapes. And you are wrong about how they behave. > It is the case that H(P,P)==0 is correct. And yet you complain when I tell you that H rejects ⟨Ĥ⟩ ⟨Ĥ⟩. Why is rejection (returning false) the correct answer for your code but not for your Turing machine? -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-09 21:14 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <yjy_I.4827$mg5.1505@fx26.iad> |
| In reply to | #39230 |
On 9/9/21 11:31 AM, olcott wrote: > On 9/9/2021 10:18 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/9/2021 6:02 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>>>>>> If we look at it at the very high level of abstraction we can >>>>>>>>> comprehend that simulating halt decider H need not abort the >>>>>>>>> simulation of its input because the simulating halt decider at >>>>>>>>> Ĥ.qx >>>>>>>>> does abort the simulation of its input. >>>>>>>> >>>>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly >>>>>>>> the same >>>>>>>> steps when presented with the same tape contents. H must >>>>>>>> transition to >>>>>>>> qn because H^.qx <H^><H^> does. >>>>>>> >>>>>>> When one machine is called with an input that refers to its own >>>>>>> machine description and another machine is called with an input that >>>>>>> does not refer to its own machine description then the two >>>>>>> computations are not the same even if their machine descriptions may >>>>>>> be otherwise identical. >>>>>> >>>>>> You are confused. Of course the computations you describe are >>>>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but >>>>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you >>>>>> refuse >>>>>> to accept anyway). >>>>> >>>>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace >>>>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ >>>>> ⟨Ĥ⟩ ??? >>>> >>>> That H^.qx <H^><H^> transitions to H^.qn has never been in doubt. It's >>>> a fact you tell us about a supposed TM that we will never see. But if >>>> H^.qx <H^><H^> transitions to H^.qn, then so does H.q0 <H^><H^>. >>> >>> You only addressed halt of what I said. >>> (1) Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ >> >> Right, so the identical Turing machine H does the same on the same >> input. >> >>> (2) This is the part that you ignored >>> >>> The execution trace of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>> shows that the input to H ⟨Ĥ⟩ ⟨Ĥ⟩ halts and H can see this execution >>> trace therefore H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy >> >> No. Stating a falsehood does not make it true. There is no possibility >> that H and the "exact copy" of H embedded in H^ can take different paths >> through their respective state graphs. > > Perhaps it is time that we discontinue our dialogue because > you lack the mandatory prerequisite knowledge of C/x86 to > understand that: > > It is the case that H(P,P)==0 is correct. No, it isn't and the 'proof' you have given has been shown to be invalid many times. > It is the case that H1((P,P)==1 is correct. Yes > It is the case that this is inconsistent. Right, so if you claim that the proof of H(P,P)==0 is valid, then you have just proved that your logic SYSTEM is inconsistent. > It is the case that this inconsistency defines a decidability > decider that correctly rejects P on the basis that P has the > pathological self-reference(Olcott 2004) error. inconsistency doesn't define anything like this. It shows that you system is broken. Since a Halt Decider is REQUIRED to be able to process any Computation as its input, <H^> <H^> isn't an 'invalid' input, but an input that foils H. That is H's problem, not the input's. All your 'Decidability Decider' does is point out some of the cases where H fails, it doesn't give it an excuse to fail. > > Because you are clueless about the x86 language you would also > lack the competence to determine whether or not H(P,P) forms > an accurate proxy computation for Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩. And you seem to be more clueless about how logic works. > >> It just that simple and, since I >> can't make it any simpler, if you can't see it by now, I don't think >> there is any hope that you ever will. >> >> But why have you changed your mind about what the correct answer is? >> You spent months arguing (about your secret C code) that H(H_Hat, H_Hat) >> == false was correct, and now that I am confirming that (for analogous >> TM) H does indeed reject <H^><H^> you complain that it is not so. OK, >> so one is real code that just gets the answer wrong, and the other an >> imagined TM, but are they not supposed to be analogous? >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-09 20:29 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <GsKdnTZmpt6MKKf8nZ2dnUU7-VPNnZ2d@giganews.com> |
| In reply to | #39228 |
On 9/9/2021 10:18 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/9/2021 6:02 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote: >>>>>>> olcott <NoOne@NoWhere.com> writes: >>> >>>>>>>> If we look at it at the very high level of abstraction we can >>>>>>>> comprehend that simulating halt decider H need not abort the >>>>>>>> simulation of its input because the simulating halt decider at Ĥ.qx >>>>>>>> does abort the simulation of its input. >>>>>>> >>>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly the same >>>>>>> steps when presented with the same tape contents. H must transition to >>>>>>> qn because H^.qx <H^><H^> does. >>>>>> >>>>>> When one machine is called with an input that refers to its own >>>>>> machine description and another machine is called with an input that >>>>>> does not refer to its own machine description then the two >>>>>> computations are not the same even if their machine descriptions may >>>>>> be otherwise identical. >>>>> >>>>> You are confused. Of course the computations you describe are >>>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but >>>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you refuse >>>>> to accept anyway). >>>> >>>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace >>>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ >>>> ⟨Ĥ⟩ ??? >>> >>> That H^.qx <H^><H^> transitions to H^.qn has never been in doubt. It's >>> a fact you tell us about a supposed TM that we will never see. But if >>> H^.qx <H^><H^> transitions to H^.qn, then so does H.q0 <H^><H^>. >> >> You only addressed halt of what I said. >> (1) Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ > > Right, so the identical Turing machine H does the same on the same > input. > >> (2) This is the part that you ignored >> >> The execution trace of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >> shows that the input to H ⟨Ĥ⟩ ⟨Ĥ⟩ halts and H can see this execution >> trace therefore H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy > > No. Stating a falsehood does not make it true. There is no possibility > that H and the "exact copy" of H embedded in H^ can take different paths > through their respective state graphs. It just that simple and, since I > can't make it any simpler, if you can't see it by now, I don't think > there is any hope that you ever will. > When I make the halt deciders an actual perfectly pure function of their inputs such that they have no access at all to data that is not on the stack it seems that things change. The good news is that I have figured out to define the halt deciders as a pure function of their inputs without hobbling them. > But why have you changed your mind about what the correct answer is? > You spent months arguing (about your secret C code) that H(H_Hat, H_Hat) > == false was correct, and now that I am confirming that (for analogous > TM) H does indeed reject <H^><H^> you complain that it is not so. OK, > so one is real code that just gets the answer wrong, and the other an > imagined TM, but are they not supposed to be analogous? > -- 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-09 21:02 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Refuting Rice's Theorem ] |
| Message-ID | <p8y_I.33728$tG6.21432@fx39.iad> |
| In reply to | #39222 |
On 9/9/21 9:47 AM, olcott wrote: > On 9/9/2021 6:02 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/8/2021 8:54 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/8/2021 7:21 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >> >>>>>>> If we look at it at the very high level of abstraction we can >>>>>>> comprehend that simulating halt decider H need not abort the >>>>>>> simulation of its input because the simulating halt decider at Ĥ.qx >>>>>>> does abort the simulation of its input. >>>>>> >>>>>> The identical "machines" at H.q0 and H^.qx must perform exactly >>>>>> the same >>>>>> steps when presented with the same tape contents. H must >>>>>> transition to >>>>>> qn because H^.qx <H^><H^> does. >>>>> >>>>> When one machine is called with an input that refers to its own >>>>> machine description and another machine is called with an input that >>>>> does not refer to its own machine description then the two >>>>> computations are not the same even if their machine descriptions may >>>>> be otherwise identical. >>>> >>>> You are confused. Of course the computations you describe are >>>> different. H.q0 <H^><H^> and H^.q0 <H^> are indeed not the same but >>>> H.q0 <H^><H^> and H^.qx <H^><H^> are (with a minor difference you >>>> refuse >>>> to accept anyway). >>> >>> You can't understand that when H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ the execution trace >>> of this simulation shows that Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ >>> ⟨Ĥ⟩ ??? >> >> That H^.qx <H^><H^> transitions to H^.qn has never been in doubt. It's >> a fact you tell us about a supposed TM that we will never see. But if >> H^.qx <H^><H^> transitions to H^.qn, then so does H.q0 <H^><H^>. > > You only addressed halt of what I said. > (1) Ĥ.qx transitions to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ > > (2) This is the part that you ignored > > The execution trace of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn > shows that the input to H ⟨Ĥ⟩ ⟨Ĥ⟩ halts and H can see this execution > trace therefore H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy How does machine H get to a state of machine H^? H does NOT contain a copy of H^ in it, as H^ doesn't exist when H is being defined. You don't seem to understand how computers work. Program X will only end up in states of program X. > > Richard pointed out that this result is inconsistent and he is correct. > It is not impossible for a formal system to derive inconsistent results. Wrong. If a Formal System yields inconsistent results, the Formal System is shown to be Inconsistent itself and thus useless. If you MISUSE a Formal system, they you show that your MISUSE is bad, and thus you weren't following the actual rules of the system. It seems that you have ACCEPTED that your system has generated an inconsistent results, that shows that SOMETHING (some LOGIC) that was used to get there is either against the rule or makes the system inconsistent. > >> That's >> all there is to it. Identical (well, technically, isomorphic) state >> transition functions result in identical behaviour, given identical tape >> contents. And you have recently "seen the light" and agreed that H >> should accept the string <H^><H^> and not reject it. >> >> If your traces confirm that H^.qx <H^><H^> transitions to H^.qn, then so >> what? That was never in dispute. But this is only confirmation by >> analogy. I have seen no execution traces of any TMs. And you don't >> have any either. >> > >
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-06 20:54 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] |
| Message-ID | <UKyZI.76259$F26.67306@fx44.iad> |
| In reply to | #38979 |
On 9/6/21 7:32 PM, olcott wrote:
> On 9/6/2021 5:55 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 9/6/2021 3:58 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/5/2021 6:14 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>>>>>> ... Ĥ includes an exact copy of H embedded at its state Ĥ.qx
>>>>
>>>>>>> You don't understand operating system process context switching.
>>>>>>
>>>>>> Change the subject. Good plan!
>>>>>
>>>>> I am not changing the subject. I am enumerating the key prerequisite
>>>>> knowledge that you are lacking, to understand what I am saying.
>>>> Your claimed knowledge of process context switching is no excuse for
>>>> not
>>>> knowing what Linz is saying about TMs.
>>>> H^ contains an almost identical copy if H embedded in at the state you
>>>> call H^.qx. Fortunately, the small differences don't prevent you from
>>>> being wrong, so I will use your word and call it an "exact copy".
>>>> You have accepted that, when construed as an input to your H, the
>>>> string
>>>> <H^><H^> encodes a halting computation. If your H has any pretensions
>>>> of being a halt decider, it should accept that string:
>>>>
>>>> H.q0 <H^><H^> |- H.qy
>>>
>>> I have already said that a bunch of times yet you did not notice
>>> because you diligently want to remain focused in disagreement mode.
>>
>> I am happy you think you've said it lots of times. I could not find any
>> but I also know not to bother asking you for references.
>>
>>>> But you keep telling us that, in fact, the "exact copy" of H
>>>> embedded in
>>>> H^ transitions to H^.qn when run with just <H^><H^> on the tape:
>>>>
>>>> H^.qx <H^><H^> |- H^.qn
>>>>
>>>> An "exact copy" of H can't make an transitions that H can't take,
>>>> and in
>>>> fact pretty much everything you've said up until now confirms that your
>>>> H in fact rejects the string <H^><H^>. All you effort has been put to
>>>> explaining why the wrong answer is in fact the right one.
>>>
>>> Like I said (and this is beyond your technical competence)
>>> int main() { H1(P,P) }; is the precise analogy to H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> Ah, proof by analogy won't fly. This line
>>
>> H^.qx <H^><H^> |- H^.qn
>>
>> shows that your H is wrong. It's a simple as that.
>>
>
> Not all all distinctly different computations can have different
> results. You can bury your head in the same and pretend that they are
> the same computation.
There is no claim that different compuations can't give the same answer.
Only that all copies of a given Computation must return the same answer
for the same input.
>
> When you actually look at the execution trace of the x86 code your
> assumption is proven wrong. That you cannot comprehend x86 is not my fault.
So you think the instruction CALL X does need the next instruction to be
from X?
Thats what you trace shows. Seems to be a broken x86.
>
>> But I think you want to stop talking about TMs because they make the
>> reason your H is wrong far too clear.
>>
>
> H ⟨Ĥ⟩ ⟨Ĥ⟩ has a dependency on Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ that does not exist in reverse.
> If the theory of computation can't comprehend this this it is simply
> insufficiently expressive.
No.
H <H^> <H^> is a computation that needs to give an specific answer. That
answer is NOT a function of anything other than <H^> <H^>
H needs to determine that answer by running that input through its
algorithm and come up with an answer.
The RIGHT answer is what H^(<H^>) does, which is Halt. The fact that H
says non-halting says its wrong.
Note, its algorithm needs to be a step by step list of instructions to
perform to get an answer. It can't be just figure out what the input
does and give the right answer, THAT is not a computation.
Maybe you still don't understand what a Computation or an Algorithm is.
You claim that it depends on H^.qx <H^> <H^> is non-sense.
At H^.qx is a COPY of the algorithm of H starting at its state q0, so we
know that H^.qx <H^> <H^> will do the same thing that H.q0 <H^> <H^>
does. Since we know that H.q0 <H^> <H^> will go to H.qn we know that
H^.qs will go to H^.qn too, and there it will Halt and thus H was wrong
to go to qn.
There is NO dependency in H on H^.qx, as H doesn't have such a state.
The algorithm in H, when given <H^> <H^> will need to try to predict
what H^.qx <H^> <H^> will do to make its decision, but actually in not
dependent on it.
Perhaps the DESIGN of H has this dependency, and the fact that you can't
get H to get the right answer just proves that a correct H doesn't exist.
>
>> If you stop writing TM configuration lines, and stop talking about
>> Linz's proof, I'll stop correcting you.
>>
>>>> Unfortunately, you can't show a flaw in a proof about TMs and TM
>>>> halting
>>>> without talking about TMs. And when you do, I will point out the
>>>> mistakes. What you claim about your H/H^ show that H fails in exactly
>>>> the same way all TMs fail to be halt deciders.
>>>
>>> It was Linz mistake to form his conclusion on the basis applying a
>>> broken halt decider to itself: Ĥ applied to ⟨Ĥ⟩.
>>
>> You agree that your H is broken? That there are inputs it can't handle?
>> I thought you'd spent 17 years arguing the exact opposite.
>>
>>> The correct way to do this would be to apply H to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> Your H fails because it does this:
>>
>> H.q0 <H^><H^> |- H.qn
>>
>> when its should do this
>>
>> H.q0 <H^><H^> |- H.qy
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <news.x.richarddamon@xoxy.net> |
|---|---|
| Date | 2021-09-05 12:34 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] |
| Message-ID | <sh2ril$m44$1@dont-email.me> |
| In reply to | #38903 |
On 9/5/21 11:28 AM, olcott wrote: > On 9/5/2021 10:22 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/4/2021 6:34 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> This is not true. The Linz H/Ĥ configuration only requires that Ĥ.qx >>>>> is an exact copy of H. >>>> >>>> No. In fact the TM embedded at Ĥ.qx is very specifically /not/ an >>>> exact >>>> copy of H. Please don't get all stroppy about this. It does not >>>> effect >>> >>> Page 319 seems to disagree. >> >> I am sure it seems so to you, but if Ĥ included "an exact copy of H", >> then Ĥ would have an accepting state like H does. What Ĥ really >> includes is an exact copy of what Linz calls H'. >> > > You simply are not paying close enough attention to the meaning of my > words. That Ĥ includes an exact copy of H embedded at its state Ĥ.qx is > not at all the same thing as saying that Ĥ <is> and exact copy of H. > > Linz says that Ĥ <is> H with some states prepended and appended. Right, he says we MODIFY H to produce H', note, if you modify something, you no longer have the original. Note, in particular, the description of state qy is now different than it was before, before it was a terminal, and now it progresses unconditionally to qa (or at least any conditions at qy that were terminal now transition to qa). Just like when you started with a UTM and MODIFIED it to be able to decide to abort its simulation, you no longer have a UTM. > >> Please have the last word and say I'm wrong again. I won't reply. It's >> pointless arguing technical details with you because you just don't do >> details, technical or otherwise. >> > > >
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-04 22:22 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] |
| Message-ID | <875yvgox33.fsf@bsb.me.uk> |
| In reply to | #38788 |
olcott <NoOne@NoWhere.com> writes: > On 9/3/2021 7:07 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/3/2021 4:40 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/3/2021 10:50 AM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> On 9/3/2021 10:16 AM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>> >>>>>>>>> On 9/3/2021 9:58 AM, Ben Bacarisse wrote: >> >>>>>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>>>> >>>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>>>> >>>>>>>> It turns out you have ducked my question at least six times previously >>>>>>>> /without/ counting any other people who has asked! This makes 7: >>>>>>>> >>>>>>> >>>>>>> I will quit dodging your dishonest dodge as soon as you acknowledge that >>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>> >>>>>> Classic crank! You'll answer when I accept a garbled falsehood, an >>>>>> obligation you are guaranteed to never have to meet! >>>>>> >>>>>> Anyway, you've dodged the question 9 times now (8 was in another >>>>>> thread). Here's you chance to go for ten times: >>>>>> >>>>>> ------------------------------------------------------------ >>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>> ------------------------------------------------------------ >>>> >>>> Yes, we're up to ten dodges. Do you want to try for 11 or will just >>>> ignore the post? >>>> >>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>> >>> This string encodes Ĥ that halts and ⟨Ĥ1⟩ ⟨Ĥ2⟩ that never halt. >> What string? >> >>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn >>> if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ does not halt >> There are at least three strings mentioned on those two lines and even >> then you don't claim that any of them encodes the halting computation of >> Ĥ applied ⟨Ĥ⟩. So no answer here. That's 11 times you've avoided >> answering. >> ------------------------------------------------------------ >> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >> ------------------------------------------------------------ >> It's not a hard question. In fact I am sure you know the answer. You >> won't answer because you either have to say something silly, or admit >> you are wrong. >> Would you like me to explain again why this question matters so much? >> > > A whole new way of making my point: You mean a whole new way to avoid answering a simple question that would show you are wrong. That's 12 times you've ducked this question: ------------------------------------------------------------ What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? ------------------------------------------------------------ Don't worry. Not answering it gives readers almost as much information as answering it would. > When the original Linz H... Just to be clear: my question is about your H. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-04 16:42 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] |
| Message-ID | <DaOdnRlirInWda78nZ2dnUU7-X3NnZ2d@giganews.com> |
| In reply to | #38865 |
On 9/4/2021 4:22 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/3/2021 7:07 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/3/2021 4:40 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> On 9/3/2021 10:50 AM, Ben Bacarisse wrote: >>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>> >>>>>>>> On 9/3/2021 10:16 AM, Ben Bacarisse wrote: >>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>> >>>>>>>>>> On 9/3/2021 9:58 AM, Ben Bacarisse wrote: >>> >>>>>>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>>>>> >>>>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>>>>> >>>>>>>>> It turns out you have ducked my question at least six times previously >>>>>>>>> /without/ counting any other people who has asked! This makes 7: >>>>>>>>> >>>>>>>> >>>>>>>> I will quit dodging your dishonest dodge as soon as you acknowledge that >>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>>> >>>>>>> Classic crank! You'll answer when I accept a garbled falsehood, an >>>>>>> obligation you are guaranteed to never have to meet! >>>>>>> >>>>>>> Anyway, you've dodged the question 9 times now (8 was in another >>>>>>> thread). Here's you chance to go for ten times: >>>>>>> >>>>>>> ------------------------------------------------------------ >>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>> ------------------------------------------------------------ >>>>> >>>>> Yes, we're up to ten dodges. Do you want to try for 11 or will just >>>>> ignore the post? >>>>> >>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>> >>>> This string encodes Ĥ that halts and ⟨Ĥ1⟩ ⟨Ĥ2⟩ that never halt. >>> What string? >>> >>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn >>>> if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ does not halt >>> There are at least three strings mentioned on those two lines and even >>> then you don't claim that any of them encodes the halting computation of >>> Ĥ applied ⟨Ĥ⟩. So no answer here. That's 11 times you've avoided >>> answering. >>> ------------------------------------------------------------ >>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>> ------------------------------------------------------------ >>> It's not a hard question. In fact I am sure you know the answer. You >>> won't answer because you either have to say something silly, or admit >>> you are wrong. >>> Would you like me to explain again why this question matters so much? >>> >> >> A whole new way of making my point: > > You mean a whole new way to avoid answering a simple question that would > show you are wrong. That's 12 times you've ducked this question: > > ------------------------------------------------------------ > What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? > ------------------------------------------------------------ > > Don't worry. Not answering it gives readers almost as much information > as answering it would. > >> When the original Linz H... > > Just to be clear: my question is about your H. > My H is applied to P is is not applied to ⟨Ĥ⟩ ⟨Ĥ⟩. When the orginal Peter Linz H is a simulating halt decider it detects the repeating pattern of its input ⟨Ĥ⟩ ⟨Ĥ⟩ and transitions to its final state of H.qy. -- 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-05 00:09 +0100 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] |
| Message-ID | <87czpondk4.fsf@bsb.me.uk> |
| In reply to | #38869 |
olcott <NoOne@NoWhere.com> writes: > On 9/4/2021 4:22 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/3/2021 7:07 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/3/2021 4:40 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> On 9/3/2021 10:50 AM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>> >>>>>>>>> On 9/3/2021 10:16 AM, Ben Bacarisse wrote: >>>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>>> >>>>>>>>>>> On 9/3/2021 9:58 AM, Ben Bacarisse wrote: >>>> >>>>>>>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>>>>>> >>>>>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>>>>>> >>>>>>>>>> It turns out you have ducked my question at least six times previously >>>>>>>>>> /without/ counting any other people who has asked! This makes 7: >>>>>>>>>> >>>>>>>>> >>>>>>>>> I will quit dodging your dishonest dodge as soon as you acknowledge that >>>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>>>> >>>>>>>> Classic crank! You'll answer when I accept a garbled falsehood, an >>>>>>>> obligation you are guaranteed to never have to meet! >>>>>>>> >>>>>>>> Anyway, you've dodged the question 9 times now (8 was in another >>>>>>>> thread). Here's you chance to go for ten times: >>>>>>>> >>>>>>>> ------------------------------------------------------------ >>>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>>> ------------------------------------------------------------ >>>>>> >>>>>> Yes, we're up to ten dodges. Do you want to try for 11 or will just >>>>>> ignore the post? >>>>>> >>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>> >>>>> This string encodes Ĥ that halts and ⟨Ĥ1⟩ ⟨Ĥ2⟩ that never halt. >>>> What string? >>>> >>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn >>>>> if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ does not halt >>>> There are at least three strings mentioned on those two lines and even >>>> then you don't claim that any of them encodes the halting computation of >>>> Ĥ applied ⟨Ĥ⟩. So no answer here. That's 11 times you've avoided >>>> answering. >>>> ------------------------------------------------------------ >>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>> ------------------------------------------------------------ >>>> It's not a hard question. In fact I am sure you know the answer. You >>>> won't answer because you either have to say something silly, or admit >>>> you are wrong. >>>> Would you like me to explain again why this question matters so much? >>>> >>> >>> A whole new way of making my point: >> >> You mean a whole new way to avoid answering a simple question that would >> show you are wrong. That's 12 times you've ducked this question: >> ------------------------------------------------------------ >> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >> ------------------------------------------------------------ >> Don't worry. Not answering it gives readers almost as much information >> as answering it would. >> >>> When the original Linz H... >> Just to be clear: my question is about your H. > > My H is applied to P is is not applied to ⟨Ĥ⟩ ⟨Ĥ⟩. Don't be silly. The question is about the TM H from which Ĥ and the string ⟨Ĥ⟩ are constructed. The fact you have other things called H is just bad writing. You can't get out of answering about the H of ⟨Ĥ⟩ by having a cat called H. So, for the H about which you were wrong to say "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting computation": ------------------------------------------------------------ What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? ------------------------------------------------------------ Ducked 13 times now... You will never answer, so why not just say you refuse? It must be tedious trying to come up with excuses all the time. Or just ignore the posts. That's simpler for me. I'll just post the question every few weeks, along with why it shows you are wrong, and you can just ignore me. That would work, would it not? -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-04 23:25 -0500 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] |
| Message-ID | <m7ydnSjxdYc326n8nZ2dnUU7-UfNnZ2d@giganews.com> |
| In reply to | #38885 |
On 9/4/2021 6:09 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/4/2021 4:22 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/3/2021 7:07 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> On 9/3/2021 4:40 PM, Ben Bacarisse wrote: >>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>> >>>>>>>> On 9/3/2021 10:50 AM, Ben Bacarisse wrote: >>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>> >>>>>>>>>> On 9/3/2021 10:16 AM, Ben Bacarisse wrote: >>>>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>>>> >>>>>>>>>>>> On 9/3/2021 9:58 AM, Ben Bacarisse wrote: >>>>> >>>>>>>>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>>>>>>> >>>>>>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>>>>>>> >>>>>>>>>>> It turns out you have ducked my question at least six times previously >>>>>>>>>>> /without/ counting any other people who has asked! This makes 7: >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> I will quit dodging your dishonest dodge as soon as you acknowledge that >>>>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>>>>> >>>>>>>>> Classic crank! You'll answer when I accept a garbled falsehood, an >>>>>>>>> obligation you are guaranteed to never have to meet! >>>>>>>>> >>>>>>>>> Anyway, you've dodged the question 9 times now (8 was in another >>>>>>>>> thread). Here's you chance to go for ten times: >>>>>>>>> >>>>>>>>> ------------------------------------------------------------ >>>>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>>>> ------------------------------------------------------------ >>>>>>> >>>>>>> Yes, we're up to ten dodges. Do you want to try for 11 or will just >>>>>>> ignore the post? >>>>>>> >>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>> >>>>>> This string encodes Ĥ that halts and ⟨Ĥ1⟩ ⟨Ĥ2⟩ that never halt. >>>>> What string? >>>>> >>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn >>>>>> if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ does not halt >>>>> There are at least three strings mentioned on those two lines and even >>>>> then you don't claim that any of them encodes the halting computation of >>>>> Ĥ applied ⟨Ĥ⟩. So no answer here. That's 11 times you've avoided >>>>> answering. >>>>> ------------------------------------------------------------ >>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>> ------------------------------------------------------------ >>>>> It's not a hard question. In fact I am sure you know the answer. You >>>>> won't answer because you either have to say something silly, or admit >>>>> you are wrong. >>>>> Would you like me to explain again why this question matters so much? >>>>> >>>> >>>> A whole new way of making my point: >>> >>> You mean a whole new way to avoid answering a simple question that would >>> show you are wrong. That's 12 times you've ducked this question: >>> ------------------------------------------------------------ >>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>> ------------------------------------------------------------ >>> Don't worry. Not answering it gives readers almost as much information >>> as answering it would. >>> >>>> When the original Linz H... >>> Just to be clear: my question is about your H. >> >> My H is applied to P is is not applied to ⟨Ĥ⟩ ⟨Ĥ⟩. > > Don't be silly. The question is about the TM H from which Ĥ and the > string ⟨Ĥ⟩ are constructed. The fact you have other things called H is > just bad writing. You can't get out of answering about the H of ⟨Ĥ⟩ by > having a cat called H. > > So, for the H about which you were wrong to say "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string > that encodes a halting computation": > > ------------------------------------------------------------ > What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? > ------------------------------------------------------------ > The Peter Linz H (not my C/x86 H) transitions to its final state of H.qy From the point of view of the Peter Linz H its input ⟨Ĥ⟩ ⟨Ĥ⟩ halts. From the point of view of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ its input never halts. So whether or not ⟨Ĥ⟩ ⟨Ĥ⟩ represents a halting computation depends on the point in the execution trace that this question refers to. Because H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy when we refer to the whole computation and not intermediate steps inside of Ĥ we can say that it halts. > Ducked 13 times now... > > You will never answer, so why not just say you refuse? It must be tedious > trying to come up with excuses all the time. Or just ignore the posts. > That's simpler for me. I'll just post the question every few weeks, > along with why it shows you are wrong, and you can just ignore me. That > would work, would it not? > -- 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-05 06:58 -0400 |
| Subject | Re: That P(P) of main() halts does not contradict H(P,P)==0 [ Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ] |
| Message-ID | <mp1ZI.28665$Dr.15985@fx40.iad> |
| In reply to | #38893 |
On 9/5/21 12:25 AM, olcott wrote: > On 9/4/2021 6:09 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/4/2021 4:22 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/3/2021 7:07 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> On 9/3/2021 4:40 PM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>> >>>>>>>>> On 9/3/2021 10:50 AM, Ben Bacarisse wrote: >>>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>>> >>>>>>>>>>> On 9/3/2021 10:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>>>>> >>>>>>>>>>>>> On 9/3/2021 9:58 AM, Ben Bacarisse wrote: >>>>>> >>>>>>>>>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>>>>>>>> >>>>>>>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>>>>>>>> >>>>>>>>>>>> It turns out you have ducked my question at least six times >>>>>>>>>>>> previously >>>>>>>>>>>> /without/ counting any other people who has asked! This >>>>>>>>>>>> makes 7: >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> I will quit dodging your dishonest dodge as soon as you >>>>>>>>>>> acknowledge that >>>>>>>>>>> The input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts. >>>>>>>>>> >>>>>>>>>> Classic crank! You'll answer when I accept a garbled >>>>>>>>>> falsehood, an >>>>>>>>>> obligation you are guaranteed to never have to meet! >>>>>>>>>> >>>>>>>>>> Anyway, you've dodged the question 9 times now (8 was in another >>>>>>>>>> thread). Here's you chance to go for ten times: >>>>>>>>>> >>>>>>>>>> ------------------------------------------------------------ >>>>>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>>>>> ------------------------------------------------------------ >>>>>>>> >>>>>>>> Yes, we're up to ten dodges. Do you want to try for 11 or will >>>>>>>> just >>>>>>>> ignore the post? >>>>>>>> >>>>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>>> >>>>>>> This string encodes Ĥ that halts and ⟨Ĥ1⟩ ⟨Ĥ2⟩ that never halt. >>>>>> What string? >>>>>> >>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn >>>>>>> if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ does not halt >>>>>> There are at least three strings mentioned on those two lines and >>>>>> even >>>>>> then you don't claim that any of them encodes the halting >>>>>> computation of >>>>>> Ĥ applied ⟨Ĥ⟩. So no answer here. That's 11 times you've avoided >>>>>> answering. >>>>>> ------------------------------------------------------------ >>>>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>>>> ------------------------------------------------------------ >>>>>> It's not a hard question. In fact I am sure you know the answer. >>>>>> You >>>>>> won't answer because you either have to say something silly, or admit >>>>>> you are wrong. >>>>>> Would you like me to explain again why this question matters so much? >>>>>> >>>>> >>>>> A whole new way of making my point: >>>> >>>> You mean a whole new way to avoid answering a simple question that >>>> would >>>> show you are wrong. That's 12 times you've ducked this question: >>>> ------------------------------------------------------------ >>>> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >>>> ------------------------------------------------------------ >>>> Don't worry. Not answering it gives readers almost as much information >>>> as answering it would. >>>> >>>>> When the original Linz H... >>>> Just to be clear: my question is about your H. >>> >>> My H is applied to P is is not applied to ⟨Ĥ⟩ ⟨Ĥ⟩. >> >> Don't be silly. The question is about the TM H from which Ĥ and the >> string ⟨Ĥ⟩ are constructed. The fact you have other things called H is >> just bad writing. You can't get out of answering about the H of ⟨Ĥ⟩ by >> having a cat called H. >> >> So, for the H about which you were wrong to say "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string >> that encodes a halting computation": >> >> ------------------------------------------------------------ >> What string encodes the halting computation of Ĥ applied ⟨Ĥ⟩? >> ------------------------------------------------------------ >> > > The Peter Linz H (not my C/x86 H) transitions to its final state of H.qy No, that is NOT what it says. He says that if H^ <H^> is a halting computation, then H to be correct would need to end up at state H.qy The key point here is that if it does, H^ will be a non-halting computation, so that answer would be wrong. > From the point of view of the Peter Linz H its input ⟨Ĥ⟩ ⟨Ĥ⟩ halts. Except that if H says H^ <H^> is Halting, it won't be. What Peter Linz definition of H says is that since in your case we do have H <H^> <H^> saying non-halting leading to H^ <H^> being a Halting Computation that H was wrong, as since H^ was halting, H needed to go to qy. Doesn't matter that if it did go to qy, then H^ would be non-halting and H still wrong. That just proves that H can't be right, and the job of Halt Deciding can't be universally done. > From the point of view of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ its input never halts. But H^ <H^> DOES Halt, so H was wrong. H doesn't simulate H^ to its halting state, but that is only because it stoppped simulating it too soon because it used bad logic and made an error. > > So whether or not ⟨Ĥ⟩ ⟨Ĥ⟩ represents a halting computation depends on > the point in the execution trace that this question refers to. Nope. Can't > > Because H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy when we refer to the whole computation and not > intermediate steps inside of Ĥ we can say that it halts. > Your H never went to qy, though for an H that goes to qn it would have needed to go to qy. You have gotten the specifications and the behavior confused. > >> Ducked 13 times now... 14 now. >> >> You will never answer, so why not just say you refuse? It must be >> tedious >> trying to come up with excuses all the time. Or just ignore the posts. >> That's simpler for me. I'll just post the question every few weeks, >> along with why it shows you are wrong, and you can just ignore me. That >> would work, would it not? >> > >
[toc] | [prev] | [next] | [standalone]
Page 36 of 37 — ← Prev page 1 … 34 35 [36] 37 Next page →
Back to top | Article view | comp.theory
csiph-web