Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #39709 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-09-21 21:25 -0500 |
| Last post | 2021-09-27 20:12 -0400 |
| Articles | 20 on this page of 235 — 8 participants |
Back to article view | Back to comp.theory
It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-21 21:25 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-21 22:51 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-21 22:20 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 06:37 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 13:46 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 19:19 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 18:33 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:02 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 19:17 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:54 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 20:45 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 23:37 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] olcott <NoOne@NoWhere.com> - 2021-09-23 07:36 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] Richard Damon <Richard@Damon-Family.org> - 2021-09-23 22:22 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] olcott <NoOne@NoWhere.com> - 2021-09-23 22:17 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:28 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] olcott <NoOne@NoWhere.com> - 2021-09-23 22:43 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ software engineering skill ] Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:58 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 09:41 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 20:00 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 19:06 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 20:17 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 19:54 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 21:30 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 20:57 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 22:33 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-24 22:38 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 06:07 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] olcott <NoOne@NoWhere.com> - 2021-09-25 09:15 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ flawed reasoning ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 12:15 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 20:49 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:13 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:30 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:50 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 22:06 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 23:57 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 07:44 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-21 22:28 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-21 21:50 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-21 23:08 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 07:45 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 09:44 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Mr Flibble <flibble@reddwarf.jmc> - 2021-09-22 18:03 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 12:15 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 19:42 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 19:00 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:28 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 20:36 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:27 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:36 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:56 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 22:12 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 00:11 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 07:56 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 19:23 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 19:17 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-23 19:24 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 20:27 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 22:42 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 22:35 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-23 21:14 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 22:19 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-23 21:26 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 22:34 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-24 00:04 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 09:36 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-24 22:18 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 16:52 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 00:28 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 19:04 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-24 20:14 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 19:51 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-24 21:32 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 20:59 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-24 22:35 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 22:39 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-25 06:11 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-25 09:02 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-25 12:17 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Jeff Barnett <jbb@notatt.com> - 2021-09-24 21:02 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 22:31 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Jeff Barnett <jbb@notatt.com> - 2021-09-25 01:22 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 21:36 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-25 15:50 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 16:56 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 00:23 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-23 22:49 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Jeff Barnett <jbb@notatt.com> - 2021-09-24 11:35 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 13:40 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-24 13:45 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 16:18 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-24 16:47 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-24 05:51 -0700
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-24 08:12 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ my patented OCR ] olcott <polcott2@gmail.com> - 2021-09-24 08:27 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data [ my patented OCR ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-24 22:42 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 06:46 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data André G. Isaak <agisaak@gm.invalid> - 2021-09-22 14:50 -0600
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 16:01 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 16:02 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-21 22:30 -0700
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 02:05 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 06:36 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 00:22 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 18:35 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 00:47 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 19:11 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:34 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 02:52 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 20:57 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 03:04 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:07 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:31 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 03:37 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:56 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 23:17 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 23:02 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 00:23 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 08:10 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 21:42 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 21:56 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:19 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-24 02:26 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:05 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-23 03:23 +0100
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 21:33 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 22:59 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 22:17 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 23:29 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-22 23:09 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 00:29 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 08:14 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 21:47 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data olcott <NoOne@NoWhere.com> - 2021-09-23 22:21 -0500
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:31 -0400
Re: It looks like I can exactly duplicate the Linz proof in x86 without static data Richard Damon <Richard@Damon-Family.org> - 2021-09-22 20:16 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 13:28 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-26 14:34 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 13:39 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-26 15:40 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 19:07 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-26 21:37 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 20:59 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 06:28 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 09:25 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 19:48 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 19:00 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 20:40 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-26 19:40 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-26 21:53 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 21:03 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-26 20:41 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 21:56 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-26 21:04 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 22:16 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-26 21:56 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-26 23:31 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-26 23:15 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 09:19 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-27 11:05 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 12:14 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-27 11:52 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 13:08 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 12:41 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-27 12:05 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 13:31 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Jeff Barnett <jbb@notatt.com> - 2021-09-27 12:53 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 14:07 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-27 20:52 +0100
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 15:44 -0500
It's halting, but not as we know it Jim (Was: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-28 02:45 +0100
Re: It's halting, but not as we know it Jim (Was: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function) olcott <NoOne@NoWhere.com> - 2021-09-27 21:05 -0500
Re: It's halting, but not as we know it Jim (Was: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function) André G. Isaak <agisaak@gm.invalid> - 2021-09-27 20:40 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 21:52 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-27 21:14 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 22:28 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 23:35 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 22:46 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 06:27 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 09:20 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 18:58 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-27 21:48 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 23:09 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-27 22:21 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 23:34 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 00:51 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 09:02 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 08:50 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 10:20 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 10:43 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 12:05 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 11:36 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 12:49 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 13:01 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 14:26 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 14:38 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 15:57 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 16:09 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 17:37 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 19:02 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 17:07 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 18:28 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function André G. Isaak <agisaak@gm.invalid> - 2021-09-28 17:37 -0600
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 21:59 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-28 06:37 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-28 09:25 -0500
Re: It's halting, but not as we know it Jim (Was: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function) Richard Damon <Richard@Damon-Family.org> - 2021-09-27 22:46 -0400
Re: It's halting, but not as we know it Jim Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-28 16:00 +0100
When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-28 10:25 -0500
Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-28 19:04 -0400
Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-29 02:14 +0100
Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-28 20:22 -0500
Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-28 22:03 -0400
Re: When an input TM description can never reach its final state it is non halting Jeff Barnett <jbb@notatt.com> - 2021-09-29 00:46 -0600
Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-29 23:44 +0100
Re: It's halting, but not as we know it Jim Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-28 16:14 +0100
Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-28 10:36 -0500
Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-28 19:09 -0400
Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-29 02:14 +0100
Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-28 20:20 -0500
Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-28 22:05 -0400
Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-29 23:17 +0100
Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-29 18:22 -0500
Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-29 20:23 -0400
Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-30 02:31 +0100
Re: When an input TM description can never reach its final state it is non halting olcott <NoOne@NoWhere.com> - 2021-09-29 20:37 -0500
Re: When an input TM description can never reach its final state it is non halting Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-30 02:51 +0100
Re: When an input TM description can never reach its final state it is non halting Richard Damon <Richard@Damon-Family.org> - 2021-09-29 21:53 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 12:12 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 06:43 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 09:32 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 20:09 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 06:33 -0400
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function olcott <NoOne@NoWhere.com> - 2021-09-27 09:27 -0500
Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function Richard Damon <Richard@Damon-Family.org> - 2021-09-27 20:12 -0400
Page 11 of 12 — ← Prev page 1 … 9 10 [11] 12 Next page →
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-28 17:07 -0600 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <sj077j$i2o$1@dont-email.me> |
| In reply to | #40045 |
On 2021-09-28 16:37, olcott wrote:
> On 9/28/2021 5:09 PM, André G. Isaak wrote:
>> On 2021-09-28 14:57, olcott wrote:
>>> On 9/28/2021 3:38 PM, André G. Isaak wrote:
>>
>>>> What appears to be over your head is the fact that if H is a halt
>>>> decider, then the computation
>>>>
>>>> int main() { H(P,P); }
>>>>
>>>> is SUPPOSED to answer the question 'does the following computation
>>>> halt':
>>>>
>>>
>>> int main() { H1(P,P); } does answer that question consistently with
>>> the behavior of int main() { P(P); }
>>>
>>> int main() { H(P,P); } is an entirely different computation even
>>> though H and H1 have identical machine code and identical input.
>>
>> But they're both being asked about the *same* input. So if both are
>> halt deciders they both need to accurately describe the behaviour of
>> int main() { P(P); }.
>>
>> Whether H1 can correctly decide this is irrelevant because your whole
>> claim what that you'd found a way to 'refute' Linz. But since your P
>> is derived from H, unless H(P, P) can correctly decide whether int
>> main() { P(P); } halts, you have failed at this goal.
>>
>> And H(P, P) does *not* correctly decide this.
>>
>> André
>>
>
> Both H1(P,P) and H(P,P) correctly decide the halt status of their input.
> This is very very difficult to understand, yet empirically verifiable
> none-the-less.
They both have the same input. They're both being asked whether int
main() { P(P); } halts.
That's the question a halt decider is supposed to answer. It is *not*
supposed to answer something about the trace of some simulated
execution. It's supposed to answer about the *actual* computation. This
is a simple matter of definition. It isn't open for debate.
It's not possible for them to both be right if they give different
answers given that they are answering the exact same question.
> The empirical proof of this relies on code that is not quite implemented
> yet. As long as pure functions H and H1 derive the same results as my
> current functions H and H1 then we have the empirical proof.
Empirical proofs are for empirical subjects. Mathematics isn't an
empirical subject.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-28 18:28 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <zsydnenfKYeLOM78nZ2dnUU7-TWdnZ2d@giganews.com> |
| In reply to | #40049 |
On 9/28/2021 6:07 PM, André G. Isaak wrote:
> On 2021-09-28 16:37, olcott wrote:
>> On 9/28/2021 5:09 PM, André G. Isaak wrote:
>>> On 2021-09-28 14:57, olcott wrote:
>>>> On 9/28/2021 3:38 PM, André G. Isaak wrote:
>>>
>>>>> What appears to be over your head is the fact that if H is a halt
>>>>> decider, then the computation
>>>>>
>>>>> int main() { H(P,P); }
>>>>>
>>>>> is SUPPOSED to answer the question 'does the following computation
>>>>> halt':
>>>>>
>>>>
>>>> int main() { H1(P,P); } does answer that question consistently with
>>>> the behavior of int main() { P(P); }
>>>>
>>>> int main() { H(P,P); } is an entirely different computation even
>>>> though H and H1 have identical machine code and identical input.
>>>
>>> But they're both being asked about the *same* input. So if both are
>>> halt deciders they both need to accurately describe the behaviour of
>>> int main() { P(P); }.
>>>
>>> Whether H1 can correctly decide this is irrelevant because your whole
>>> claim what that you'd found a way to 'refute' Linz. But since your P
>>> is derived from H, unless H(P, P) can correctly decide whether int
>>> main() { P(P); } halts, you have failed at this goal.
>>>
>>> And H(P, P) does *not* correctly decide this.
>>>
>>> André
>>>
>>
>> Both H1(P,P) and H(P,P) correctly decide the halt status of their
>> input. This is very very difficult to understand, yet empirically
>> verifiable none-the-less.
>
> They both have the same input. They're both being asked whether int
> main() { P(P); } halts.
>
> That's the question a halt decider is supposed to answer. It is *not*
> supposed to answer something about the trace of some simulated
> execution. It's supposed to answer about the *actual* computation. This
> is a simple matter of definition. It isn't open for debate.
>
> It's not possible for them to both be right if they give different
> answers given that they are answering the exact same question.
>
Yes we agree, that was not the issue. Is it possible for them to have
identical machine code and identical inputs and derive opposite results?
>> The empirical proof of this relies on code that is not quite
>> implemented yet. As long as pure functions H and H1 derive the same
>> results as my current functions H and H1 then we have the empirical
>> proof.
>
> Empirical proofs are for empirical subjects. Mathematics isn't an
> empirical subject.
>
> André
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-28 17:37 -0600 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <sj08v7$r0r$1@dont-email.me> |
| In reply to | #40052 |
On 2021-09-28 17:28, olcott wrote:
> On 9/28/2021 6:07 PM, André G. Isaak wrote:
>> On 2021-09-28 16:37, olcott wrote:
>>> On 9/28/2021 5:09 PM, André G. Isaak wrote:
>>>> On 2021-09-28 14:57, olcott wrote:
>>>>> On 9/28/2021 3:38 PM, André G. Isaak wrote:
>>>>
>>>>>> What appears to be over your head is the fact that if H is a halt
>>>>>> decider, then the computation
>>>>>>
>>>>>> int main() { H(P,P); }
>>>>>>
>>>>>> is SUPPOSED to answer the question 'does the following computation
>>>>>> halt':
>>>>>>
>>>>>
>>>>> int main() { H1(P,P); } does answer that question consistently with
>>>>> the behavior of int main() { P(P); }
>>>>>
>>>>> int main() { H(P,P); } is an entirely different computation even
>>>>> though H and H1 have identical machine code and identical input.
>>>>
>>>> But they're both being asked about the *same* input. So if both are
>>>> halt deciders they both need to accurately describe the behaviour of
>>>> int main() { P(P); }.
>>>>
>>>> Whether H1 can correctly decide this is irrelevant because your
>>>> whole claim what that you'd found a way to 'refute' Linz. But since
>>>> your P is derived from H, unless H(P, P) can correctly decide
>>>> whether int main() { P(P); } halts, you have failed at this goal.
>>>>
>>>> And H(P, P) does *not* correctly decide this.
>>>>
>>>> André
>>>>
>>>
>>> Both H1(P,P) and H(P,P) correctly decide the halt status of their
>>> input. This is very very difficult to understand, yet empirically
>>> verifiable none-the-less.
>>
>> They both have the same input. They're both being asked whether int
>> main() { P(P); } halts.
>>
>> That's the question a halt decider is supposed to answer. It is *not*
>> supposed to answer something about the trace of some simulated
>> execution. It's supposed to answer about the *actual* computation.
>> This is a simple matter of definition. It isn't open for debate.
>>
>> It's not possible for them to both be right if they give different
>> answers given that they are answering the exact same question.
>>
>
> Yes we agree, that was not the issue. Is it possible for them to have
> identical machine code and identical inputs and derive opposite results?
No, we don't agree. Above you claim that "Both H1(P,P) and H(P,P)
correctly decide the halt status of their input". I am stating that that
is flat-out wrong. Your H(P,P) does *not* correctly decide the halting
status of its input.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-28 21:59 -0400 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <GLP4J.151454$o45.28683@fx46.iad> |
| In reply to | #40052 |
On 9/28/21 7:28 PM, olcott wrote:
> On 9/28/2021 6:07 PM, André G. Isaak wrote:
>> On 2021-09-28 16:37, olcott wrote:
>>> On 9/28/2021 5:09 PM, André G. Isaak wrote:
>>>> On 2021-09-28 14:57, olcott wrote:
>>>>> On 9/28/2021 3:38 PM, André G. Isaak wrote:
>>>>
>>>>>> What appears to be over your head is the fact that if H is a halt
>>>>>> decider, then the computation
>>>>>>
>>>>>> int main() { H(P,P); }
>>>>>>
>>>>>> is SUPPOSED to answer the question 'does the following computation
>>>>>> halt':
>>>>>>
>>>>>
>>>>> int main() { H1(P,P); } does answer that question consistently with
>>>>> the behavior of int main() { P(P); }
>>>>>
>>>>> int main() { H(P,P); } is an entirely different computation even
>>>>> though H and H1 have identical machine code and identical input.
>>>>
>>>> But they're both being asked about the *same* input. So if both are
>>>> halt deciders they both need to accurately describe the behaviour of
>>>> int main() { P(P); }.
>>>>
>>>> Whether H1 can correctly decide this is irrelevant because your
>>>> whole claim what that you'd found a way to 'refute' Linz. But since
>>>> your P is derived from H, unless H(P, P) can correctly decide
>>>> whether int main() { P(P); } halts, you have failed at this goal.
>>>>
>>>> And H(P, P) does *not* correctly decide this.
>>>>
>>>> André
>>>>
>>>
>>> Both H1(P,P) and H(P,P) correctly decide the halt status of their
>>> input. This is very very difficult to understand, yet empirically
>>> verifiable none-the-less.
>>
>> They both have the same input. They're both being asked whether int
>> main() { P(P); } halts.
>>
>> That's the question a halt decider is supposed to answer. It is *not*
>> supposed to answer something about the trace of some simulated
>> execution. It's supposed to answer about the *actual* computation.
>> This is a simple matter of definition. It isn't open for debate.
>>
>> It's not possible for them to both be right if they give different
>> answers given that they are answering the exact same question.
>>
>
> Yes we agree, that was not the issue. Is it possible for them to have
> identical machine code and identical inputs and derive opposite results?
No. But it may be that the input that differs is just the PC the routine
runs at.
Think about it. The output of every normal computer opcode is strictly a
computation of the opcode and some inputs to that instruction.
Thus, if you have the identical sequence of instructions, and feed all
of them the exact same inputs, the results must be exactly the same.
If you get a difference in results, you WILL be able to trace it back to
some instruction where the first difference occured.
That instruction MUST have gotten a different input from the two copies.
EIther the opcode was different, or an input was different.
If you claim the 'inputs' are the same, this means that EVERYTHING that
goes into an instruction must have been the same.
Either your H and H1 aren't actually identical code, or the depend on
something that wasn't the same in the exection of the two copies.
>
>>> The empirical proof of this relies on code that is not quite
>>> implemented yet. As long as pure functions H and H1 derive the same
>>> results as my current functions H and H1 then we have the empirical
>>> proof.
>>
>> Empirical proofs are for empirical subjects. Mathematics isn't an
>> empirical subject.
>>
>> André
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-28 06:37 -0400 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <gfC4J.25207$nh7.18877@fx22.iad> |
| In reply to | #40015 |
On 9/28/21 12:09 AM, olcott wrote: > On 9/27/2021 10:48 PM, André G. Isaak wrote: >> On 2021-09-27 21:28, olcott wrote: >>> On 9/27/2021 10:14 PM, André G. Isaak wrote: >>>> On 2021-09-27 20:52, olcott wrote: >>>>> On 9/27/2021 9:40 PM, André G. Isaak wrote: >>>>>> On 2021-09-27 20:05, olcott wrote: >>>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>>>> >>>>>>> You know that the input to a halt decider is a TM description and >>>>>>> not a TM. This means that you know that it is not about whether >>>>>>> or not Ĥ halts. >>>>>>> >>>>>>> It it about whether or not the simulation of the first parameter >>>>>>> ⟨Ĥ⟩ to Ĥ.qx halts on its input ⟨Ĥ⟩. >>>>>> >>>>>> The position you're taking here is, to put it bluntly, simply absurd. >>>>>> >>>>>> A halt decider takes a description of a computation as its input. >>>>>> It is supposed to determine whether the computation described by >>>>>> that description halts. >>>>>> >>>>> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>>>> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >>>>> >>>>> I merely adapted the Linz annotations to be more clear. >>>>> It is not about whether or not Ĥ halts on ⟨Ĥ⟩. >>>>> It is about whether or not the simulation of ⟨Ĥ⟩ on ⟨Ĥ⟩ at Ĥ.qx halts. >>>> >>>> I was not commenting on your (mis)use of notation and nothing in >>>> your response even remotely addressed what I was saying. I was >>>> commenting on the ridiculous statement that "You know that the input >>>> to a halt decider is a TM description and not a TM. This means that >>>> you know that it is not about whether or not Ĥ halts." >>>> >>>> This statement is simply wrong. Spectacularly wrong. If you don't >>>> understand what the halting problem is even about, you shouldn't be >>>> working on it at all. >>>> >>>> André >>>> >>> >>> It may seem that way to you only because you have not bothered to >>> think it all the way through. >>> >>> It may be that you fail to comprehend the following, yet a failure of >>> comprehension is less than no rebuttal at all: >>> >>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to Ĥ applied to ⟨Ĥ⟩. >>> >>> Ĥ applied to ⟨Ĥ⟩ is NOT computationally equivalent to H applied to >>> ⟨Ĥ⟩ ⟨Ĥ⟩. >> >> >> Of course H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is not equivalent to Ĥ applied to ⟨Ĥ⟩. >> But if H is a halt decider then by the very definition of 'halt >> decider' H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ must correctly predict the behaviour of >> applied to ⟨Ĥ⟩. >> >> And the above two statements contradict one another. You seem to be >> claiming that A is equivalent to B but that B is not equivalent to A. >> You should learn what 'equivalent' means. >> > > I said it incorrectly because I was thinking of my H1/H > > H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to > Ĥ applied to ⟨Ĥ⟩ IMPOSSIBLE. H and H^ are different operations, they can't be computationally equivalent (unless you are thinking that ALL functions that Halt are commputationally equivalent). That is like saying that cos and cosh are computationally equivalent because they use a similar summation in them. > > H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is NOT computationally equivalent to > Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ THen H^ was built wrong. Since the DEFINITION of H^ is that at H^.qx it has a copy of the computation H placed there, and the tape at that state is by definition <H^> <H^>, if the computations at H^.qx and H are not the same, your H^ is defined wrong. > >>> It turns out that when the input program P calls the same halt >>> decider H that is deciding its halting status this is computationally >>> distinct from another identically coded halt decider H1 that is not >>> called by the input program P. >> >> A description of a computation is a description of a computation. ⟨P⟩ >> ⟨P⟩ describes the same computation regardless of which program it is >> passed to as an input. To say otherwise suggests you don't even grasp >> what the term 'description' means. >> > > No it does not. So, you are arguing that A is not A. Sounds like YOU are in the Liar's Paradox. > >> If you were tasked with coming up with a computer program which took >> as its input a description of an airplane and determined whether that >> airplane was flightworthy, do you seriously believe that anyone would >> be interested in a program which determined this for anything other >> than the actual airplane which was described? If you claim that the >> description represents a 'different airplane' when passed to your >> program than when the description appears independently do you >> seriously think anyone is going to buy that? >> >> André >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-28 09:25 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <ANednQvuh5JVuM78nZ2dnUU7-dnNnZ2d@giganews.com> |
| In reply to | #40020 |
On 9/28/2021 5:37 AM, Richard Damon wrote:
> On 9/28/21 12:09 AM, olcott wrote:
>> On 9/27/2021 10:48 PM, André G. Isaak wrote:
>>> On 2021-09-27 21:28, olcott wrote:
>>>> On 9/27/2021 10:14 PM, André G. Isaak wrote:
>>>>> On 2021-09-27 20:52, olcott wrote:
>>>>>> On 9/27/2021 9:40 PM, André G. Isaak wrote:
>>>>>>> On 2021-09-27 20:05, olcott wrote:
>>>>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote:
>>>>>>>
>>>>>>>> You know that the input to a halt decider is a TM description and
>>>>>>>> not a TM. This means that you know that it is not about whether
>>>>>>>> or not Ĥ halts.
>>>>>>>>
>>>>>>>> It it about whether or not the simulation of the first parameter
>>>>>>>> ⟨Ĥ⟩ to Ĥ.qx halts on its input ⟨Ĥ⟩.
>>>>>>>
>>>>>>> The position you're taking here is, to put it bluntly, simply absurd.
>>>>>>>
>>>>>>> A halt decider takes a description of a computation as its input.
>>>>>>> It is supposed to determine whether the computation described by
>>>>>>> that description halts.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> I merely adapted the Linz annotations to be more clear.
>>>>>> It is not about whether or not Ĥ halts on ⟨Ĥ⟩.
>>>>>> It is about whether or not the simulation of ⟨Ĥ⟩ on ⟨Ĥ⟩ at Ĥ.qx halts.
>>>>>
>>>>> I was not commenting on your (mis)use of notation and nothing in
>>>>> your response even remotely addressed what I was saying. I was
>>>>> commenting on the ridiculous statement that "You know that the input
>>>>> to a halt decider is a TM description and not a TM. This means that
>>>>> you know that it is not about whether or not Ĥ halts."
>>>>>
>>>>> This statement is simply wrong. Spectacularly wrong. If you don't
>>>>> understand what the halting problem is even about, you shouldn't be
>>>>> working on it at all.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> It may seem that way to you only because you have not bothered to
>>>> think it all the way through.
>>>>
>>>> It may be that you fail to comprehend the following, yet a failure of
>>>> comprehension is less than no rebuttal at all:
>>>>
>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to Ĥ applied to ⟨Ĥ⟩.
>>>>
>>>> Ĥ applied to ⟨Ĥ⟩ is NOT computationally equivalent to H applied to
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>>
>>> Of course H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is not equivalent to Ĥ applied to ⟨Ĥ⟩.
>>> But if H is a halt decider then by the very definition of 'halt
>>> decider' H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ must correctly predict the behaviour of
>>> applied to ⟨Ĥ⟩.
>>>
>>> And the above two statements contradict one another. You seem to be
>>> claiming that A is equivalent to B but that B is not equivalent to A.
>>> You should learn what 'equivalent' means.
>>>
>>
>> I said it incorrectly because I was thinking of my H1/H
>>
>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to
>> Ĥ applied to ⟨Ĥ⟩
>
> IMPOSSIBLE. H and H^ are different operations, they can't be
> computationally equivalent (unless you are thinking that ALL functions
> that Halt are commputationally equivalent).
>
In x86utm int main() { H1(P,P); } has an execution trace that is
essentially the same as int main() { P(P); }
> That is like saying that cos and cosh are computationally equivalent
> because they use a similar summation in them.
>
>>
>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is NOT computationally equivalent to
>> Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>
> THen H^ was built wrong. Since the DEFINITION of H^ is that at H^.qx it
> has a copy of the computation H placed there, and the tape at that state
> is by definition <H^> <H^>, if the computations at H^.qx and H are not
> the same, your H^ is defined wrong.
>
>>
>>>> It turns out that when the input program P calls the same halt
>>>> decider H that is deciding its halting status this is computationally
>>>> distinct from another identically coded halt decider H1 that is not
>>>> called by the input program P.
>>>
>>> A description of a computation is a description of a computation. ⟨P⟩
>>> ⟨P⟩ describes the same computation regardless of which program it is
>>> passed to as an input. To say otherwise suggests you don't even grasp
>>> what the term 'description' means.
>>>
>>
>> No it does not.
>
> So, you are arguing that A is not A.
>
> Sounds like YOU are in the Liar's Paradox.
>
>>
>>> If you were tasked with coming up with a computer program which took
>>> as its input a description of an airplane and determined whether that
>>> airplane was flightworthy, do you seriously believe that anyone would
>>> be interested in a program which determined this for anything other
>>> than the actual airplane which was described? If you claim that the
>>> description represents a 'different airplane' when passed to your
>>> program than when the description appears independently do you
>>> seriously think anyone is going to buy that?
>>>
>>> André
>>>
>>
>>
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-27 22:46 -0400 |
| Subject | Re: It's halting, but not as we know it Jim (Was: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function) |
| Message-ID | <9mv4J.4706$yk1.4153@fx13.iad> |
| In reply to | #40003 |
On 9/27/21 10:05 PM, olcott wrote: > 9/27/2021 8:45 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >> >>>>> This is the key basis of my refutation of the halting theorem: >>>> >>>> You would have to find a logical flaw in the proofs. All of them. But >>>> you have not even read the "proper" proof in Linz. The one that you >>>> can >>>> understand is only presented for historical reasons. >>> >>> The logical flaw is that the halting theorem attempts to show that the >>> halting problem is undecidable by a counter-example that is clearly >>> decidable as non-halting. >> >> But first you changed the definition of halting: >> >> "This definition of halting circumvents the pathological >> self-reference error for every simulating halt decider: >> >> An input is decided to be halting only if its simulation never needs >> to be stopped by any simulating halt decider anywhere in its entire >> invocation chain." >> >> The result is that you are no longer talking the halting problem. It's >> a new problem: the Peter Olcott Other Halting problem where a decider >> that rejects some halting computation is "correct". >> >> "On that basis" (you go on to say): >> >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> H(<Ĥ>,<Ĥ>) ⊢* H.qn >> >> clearly showing H rejecting a halting computation. You are admirably >> clear. To avoid the problem present in the proof, you redefine halting >> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >> >>>>> All of the "rebuttals" have taken the form of the strawman error: >>>>> The halting theorem does not specify a simulating halt decider. >>>>> This is no actual rebuttal to the original claim at all. >>>> >>>> No, the rebuttals start with a simple fact: false is not the correct >>>> answer for a halting computation. The rest of the rebuttal comes from >>>> you (it has to since you are carefully hiding the code): >> >> You cut the part where I quote you acknowledging that >> Halts(Confound_Halts, Confound_Halts) returns false despite >> Confound_Halts(Confound_Halts) being a finite computation. >> >> But no matter, it was there about TMs in 2017: >> >> On that basis >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> H(<Ĥ>,<Ĥ>) ⊢* H.qn >> >> "That basis" being "the other kind of halting that does not mean >> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). >> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >> >> You have the wrong annotations again. This is simple dishonesty because >> I've told just the other day not to leave off the crucial texts. You >> have no valid excuse to keep doing it. You can't change what Linz says >> a halt decider must do and have any credibility in talking about the >> halting problem. >> >> This all appears to be nothing but a pathetic attempt to hide what you >> have been clear about in the past because you can add the correct >> annotations without contradicting yourself: >> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >> if Ĥ applied to ⟨Ĥ⟩ halts >> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >> if Ĥ applied to ⟨Ĥ⟩ does not halt >> > > It is not about Ĥ applied to ⟨Ĥ⟩ > It is about Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ Wrong. Read the conditions above, the Definition of what H is supposed to do, which the copy of it in H^ will also need to do, to be RIGHT, is totally based on what H^ applied to H^ will do. > > The halt decider is not at Ĥ.q0 it is at Ĥ.qx Right, H^ USES a copy of the Halt Decider H, and has that copy starting at state H^.qx. H^ is NOT a Halt Decider, it is the machine that the Halt Decider needs to decide, and is designed to foil the Halt Decider. > > You know that the input to a halt decider is a TM description and not a > TM. This means that you know that it is not about whether or not Ĥ halts. > > It it about whether or not the simulation of the first parameter ⟨Ĥ⟩ to > Ĥ.qx halts on its input ⟨Ĥ⟩. > WRONG. Your FIRST statement is rignt. the input s a Turing Machine Descrption. The input is <H^? <H^> That input REPRESENT the Turing Machine H^ applied to the input <H^>. The QUESTION that H is asked to decide is does that machine [ H^ applied to <H^> ] halt when run or not, i.e does H^ Halt. Maybe you should actually read the problem statement. Why do you think the description of what H is supposed to do uses the phrase if P applied to I halts (where P = H^, and I = <H^>) Where do you see anything talking about what the simulation of the first parameter does? THe problem doesn't even specify that H even does a simulation, so it can't talk about what the simulation does. I wonder if your problem is that you are so stuck on the idea that Truth needs to be provable that you just can't even think about H needing to make its decision on something it just has to 'figure out' and might not be able to formally prove.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-28 16:00 +0100 |
| Subject | Re: It's halting, but not as we know it Jim |
| Message-ID | <87k0j0rbhk.fsf@bsb.me.uk> |
| In reply to | #40003 |
olcott <NoOne@NoWhere.com> writes: > 9/27/2021 8:45 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >> >> You have the wrong annotations again. This is simple dishonesty because >> I've told just the other day not to leave off the crucial texts. You >> have no valid excuse to keep doing it. >> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >> if Ĥ applied to ⟨Ĥ⟩ halts >> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >> if Ĥ applied to ⟨Ĥ⟩ does not halt > > It is not about Ĥ applied to ⟨Ĥ⟩ Yes it is. Go read those three pages from Linz again. If you can't understand what he is saying, you have no standing in the debate. You can keep the extra states. You can add any bogus annotations you like. But you can't remove the ones that are determined by the specification given for H by Linz. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-28 10:25 -0500 |
| Subject | When an input TM description can never reach its final state it is non halting |
| Message-ID | <2Zmdnd9S2o9rrs78nZ2dnUU7-IfNnZ2d@giganews.com> |
| In reply to | #40025 |
On 9/28/2021 10:00 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: > >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>>> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >>> >>> You have the wrong annotations again. This is simple dishonesty because >>> I've told just the other day not to leave off the crucial texts. You >>> have no valid excuse to keep doing it. > >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>> if Ĥ applied to ⟨Ĥ⟩ halts >>> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>> if Ĥ applied to ⟨Ĥ⟩ does not halt >> >> It is not about Ĥ applied to ⟨Ĥ⟩ > > Yes it is. Go read those three pages from Linz again. If you can't > understand what he is saying, you have no standing in the debate. > The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. The halt decider does not decide that halt status of itself. The halt decider decides the halt status of its input. The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. Since you already know these things are true denying them is dishonest. > You can keep the extra states. You can add any bogus annotations you > like. But you can't remove the ones that are determined by the > specification given for H by Linz. > -- 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-28 19:04 -0400 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <scN4J.36018$6u6.7947@fx03.iad> |
| In reply to | #40029 |
On 9/28/21 11:25 AM, olcott wrote: > On 9/28/2021 10:00 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>>>> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >>>> >>>> You have the wrong annotations again. This is simple dishonesty >>>> because >>>> I've told just the other day not to leave off the crucial texts. You >>>> have no valid excuse to keep doing it. >> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>> if Ĥ applied to ⟨Ĥ⟩ halts >>>> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>> if Ĥ applied to ⟨Ĥ⟩ does not halt >>> >>> It is not about Ĥ applied to ⟨Ĥ⟩ >> >> Yes it is. Go read those three pages from Linz again. If you can't >> understand what he is saying, you have no standing in the debate. >> > > The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. > The halt decider does not decide that halt status of itself. > The halt decider decides the halt status of its input. > The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. What does the statement: >>>> if Ĥ applied to ⟨Ĥ⟩ halts Mean to you? What is it that matters in this question. If it isn't "Ĥ applied to ⟨Ĥ⟩", why does it say that? Read what Linz says.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-29 02:14 +0100 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <87lf3gp4h9.fsf@bsb.me.uk> |
| In reply to | #40029 |
olcott <NoOne@NoWhere.com> writes: > On 9/28/2021 10:00 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>>>> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >>>> >>>> You have the wrong annotations again. This is simple dishonesty because >>>> I've told just the other day not to leave off the crucial texts. You >>>> have no valid excuse to keep doing it. >> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>> if Ĥ applied to ⟨Ĥ⟩ halts >>>> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>> if Ĥ applied to ⟨Ĥ⟩ does not halt >>> >>> It is not about Ĥ applied to ⟨Ĥ⟩ >> >> Yes it is. Go read those three pages from Linz again. If you can't >> understand what he is saying, you have no standing in the debate. > > The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. > The halt decider does not decide that halt status of itself. > The halt decider decides the halt status of its input. > The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. > > Since you already know these things are true denying them is > dishonest. 2+2 is 4 Macron is the president of France Linz wrote a book about automata theory Since you already know these things are true denying them is dishonest. You are clearly lost but you don't have the courage to ask for help, but any side discussion is good for you because you need to draw fire from the fact that you are not talking about the halting problem. Once you have re-defined what the terms mean so that H is deemed to be correct in rejecting a halting computation, you have to draw the flack somewhere else. It's futile trying to get you to understand but I will point out you are being deceptive every time you leave off Linz's perfectly correct annotations. They are the ones that matters. >> You can keep the extra states. You can add any bogus annotations you >> like. But you can't remove the ones that are determined by the >> specification given for H by Linz. >> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-28 20:22 -0500 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <d7qdnTevBu0hIs78nZ2dnUU7-WVQAAAA@giganews.com> |
| In reply to | #40055 |
On 9/28/2021 8:14 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/28/2021 10:00 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>>>>> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >>>>> >>>>> You have the wrong annotations again. This is simple dishonesty because >>>>> I've told just the other day not to leave off the crucial texts. You >>>>> have no valid excuse to keep doing it. >>> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>> if Ĥ applied to ⟨Ĥ⟩ halts >>>>> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt >>>> >>>> It is not about Ĥ applied to ⟨Ĥ⟩ >>> >>> Yes it is. Go read those three pages from Linz again. If you can't >>> understand what he is saying, you have no standing in the debate. >> >> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. >> The halt decider does not decide that halt status of itself. >> The halt decider decides the halt status of its input. >> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. >> >> Since you already know these things are true denying them is >> dishonest. > > 2+2 is 4 > Macron is the president of France > Linz wrote a book about automata theory > > Since you already know these things are true denying them is dishonest. > > You are clearly lost but you don't have the courage to ask for help, but > any side discussion is good for you because you need to draw fire from > the fact that you are not talking about the halting problem. Once you > have re-defined what the terms mean so that H is deemed to be correct in > rejecting a halting computation, you have to draw the flack somewhere > else. > > It's futile trying to get you to understand but I will point out you are > being deceptive every time you leave off Linz's perfectly correct > annotations. They are the ones that matters. > In other words you cannot possibly provide anything that would look like a rebuttal to even the very gullible. >>> You can keep the extra states. You can add any bogus annotations you >>> like. But you can't remove the ones that are determined by the >>> specification given for H by Linz. >>> > -- 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-28 22:03 -0400 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <pPP4J.151455$o45.93147@fx46.iad> |
| In reply to | #40058 |
On 9/28/21 9:22 PM, olcott wrote: > On 9/28/2021 8:14 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/28/2021 10:00 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>>>>>> >>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >>>>>> >>>>>> You have the wrong annotations again. This is simple dishonesty >>>>>> because >>>>>> I've told just the other day not to leave off the crucial texts. You >>>>>> have no valid excuse to keep doing it. >>>> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>> if Ĥ applied to ⟨Ĥ⟩ halts >>>>>> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt >>>>> >>>>> It is not about Ĥ applied to ⟨Ĥ⟩ >>>> >>>> Yes it is. Go read those three pages from Linz again. If you can't >>>> understand what he is saying, you have no standing in the debate. >>> >>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. >>> The halt decider does not decide that halt status of itself. >>> The halt decider decides the halt status of its input. >>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. >>> >>> Since you already know these things are true denying them is >>> dishonest. >> >> 2+2 is 4 >> Macron is the president of France >> Linz wrote a book about automata theory >> >> Since you already know these things are true denying them is dishonest. >> >> You are clearly lost but you don't have the courage to ask for help, but >> any side discussion is good for you because you need to draw fire from >> the fact that you are not talking about the halting problem. Once you >> have re-defined what the terms mean so that H is deemed to be correct in >> rejecting a halting computation, you have to draw the flack somewhere >> else. >> >> It's futile trying to get you to understand but I will point out you are >> being deceptive every time you leave off Linz's perfectly correct >> annotations. They are the ones that matters. >> > > In other words you cannot possibly provide anything that would look like > a rebuttal to even the very gullible. No, he is saying you are too dumb to recognize the errors in your arguments so you just ignore anything that people say that disagrees with you and call it a dishonest dodge, whiich is the most dishonest dodge of all. You are so gullible, you have gaslight yourself into believing your own lies. > >>>> You can keep the extra states. You can add any bogus annotations you >>>> like. But you can't remove the ones that are determined by the >>>> specification given for H by Linz. >>>> >> > >
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2021-09-29 00:46 -0600 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <sj1254$ni5$1@dont-email.me> |
| In reply to | #40062 |
On 9/28/2021 8:03 PM, Richard Damon wrote: > On 9/28/21 9:22 PM, olcott wrote: >> On 9/28/2021 8:14 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/28/2021 10:00 AM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>>>>>>> >>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >>>>>>> >>>>>>> You have the wrong annotations again. This is simple dishonesty >>>>>>> because >>>>>>> I've told just the other day not to leave off the crucial texts. You >>>>>>> have no valid excuse to keep doing it. >>>>> >>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts >>>>>>> >>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt >>>>>> >>>>>> It is not about Ĥ applied to ⟨Ĥ⟩ >>>>> >>>>> Yes it is. Go read those three pages from Linz again. If you can't >>>>> understand what he is saying, you have no standing in the debate. >>>> >>>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. >>>> The halt decider does not decide that halt status of itself. >>>> The halt decider decides the halt status of its input. >>>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. >>>> >>>> Since you already know these things are true denying them is >>>> dishonest. >>> >>> 2+2 is 4 >>> Macron is the president of France >>> Linz wrote a book about automata theory >>> >>> Since you already know these things are true denying them is dishonest. >>> >>> You are clearly lost but you don't have the courage to ask for help, but >>> any side discussion is good for you because you need to draw fire from >>> the fact that you are not talking about the halting problem. Once you >>> have re-defined what the terms mean so that H is deemed to be correct in >>> rejecting a halting computation, you have to draw the flack somewhere >>> else. >>> >>> It's futile trying to get you to understand but I will point out you are >>> being deceptive every time you leave off Linz's perfectly correct >>> annotations. They are the ones that matters. >>> >> >> In other words you cannot possibly provide anything that would look like >> a rebuttal to even the very gullible. > > No, he is saying you are too dumb to recognize the errors in your > arguments so you just ignore anything that people say that disagrees > with you and call it a dishonest dodge, whiich is the most dishonest > dodge of all. > > You are so gullible, you have gaslight yourself into believing your own > lies. There is another possibility: He/she has become emotionally attached to his "accomplishments". The actual display that the cockroach in his/her kitchen knows as much about the topic as he/she does has crushed his/her ego. If he/she became honest an admitted the utter failure of the last two decades of his/her life, his/her entire personality structure would collapse. You have surely noticed the total resistance to everyone's attempts to be helpful and improve his/her state. Well that resistance is minor to what would be shown to a mental health professional. He/she would rather continue the futile fight to be recognized as a world class mathematician than be instantly classified as a whack job. The fact that the classification, in both instances, has already been determined has not yet penetrated his/her near empty skull. -- Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-29 23:44 +0100 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <874ka3ovc3.fsf@bsb.me.uk> |
| In reply to | #40058 |
olcott <NoOne@NoWhere.com> writes: > In other words you cannot possibly provide anything that would look > like a rebuttal to even the very gullible. I wonder what would constitute a "rebuttal" to you? Linz tells us that the halting problem is (in part) about a TM H such that H(<M>, w) ⊢* H.qn if and only iff M(x) does not halts. You change what "halting" means so that "on that basis" Ĥ(<Ĥ>) ⊢* Ĥ.qn H(<Ĥ>,<Ĥ>) ⊢* H.qn and you expect people to think you have something to say about the theorem in Linz? That's about as simple as I can put it, and it uses mostly your writing on the topic. But seeing the problem does rely on you knowing what these formal symbols mean and how they are manipulated. You can, apparently, write the two lines above and not see that H is not "exactly and precisely as in Linz". I think you see the notation as vague and suggestive rather that exact and not subject to interpretation. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-28 16:14 +0100 |
| Subject | Re: It's halting, but not as we know it Jim |
| Message-ID | <87bl4crav2.fsf@bsb.me.uk> |
| In reply to | #40003 |
olcott <NoOne@NoWhere.com> writes: > 9/27/2021 8:45 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >> >>>>> This is the key basis of my refutation of the halting theorem: >>>> >>>> You would have to find a logical flaw in the proofs. All of them. But >>>> you have not even read the "proper" proof in Linz. The one that you can >>>> understand is only presented for historical reasons. >>> >>> The logical flaw is that the halting theorem attempts to show that the >>> halting problem is undecidable by a counter-example that is clearly >>> decidable as non-halting. >> But first you changed the definition of halting: >> "This definition of halting circumvents the pathological >> self-reference error for every simulating halt decider: >> An input is decided to be halting only if its simulation never needs >> to be stopped by any simulating halt decider anywhere in its entire >> invocation chain." >> The result is that you are no longer talking the halting problem. It's >> a new problem: the Peter Olcott Other Halting problem where a decider >> that rejects some halting computation is "correct". >> "On that basis" (you go on to say): >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> H(<Ĥ>,<Ĥ>) ⊢* H.qn >> clearly showing H rejecting a halting computation. You are admirably >> clear. To avoid the problem present in the proof, you redefine halting >> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >> >>>>> All of the "rebuttals" have taken the form of the strawman error: >>>>> The halting theorem does not specify a simulating halt decider. >>>>> This is no actual rebuttal to the original claim at all. >>>> >>>> No, the rebuttals start with a simple fact: false is not the correct >>>> answer for a halting computation. The rest of the rebuttal comes from >>>> you (it has to since you are carefully hiding the code): >> You cut the part where I quote you acknowledging that >> Halts(Confound_Halts, Confound_Halts) returns false despite >> Confound_Halts(Confound_Halts) being a finite computation. >> But no matter, it was there about TMs in 2017: >> On that basis >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> H(<Ĥ>,<Ĥ>) ⊢* H.qn >> "That basis" being "the other kind of halting that does not mean >> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). It's extraordinary that you complain that no one ever points out errors, or that there arguments are all straw men, but when it's clearly pointed out to you, using your own posts, you have nothing to say! Not a word. You can't say anything because rule 1 of crank posting is to never retract anything significant. You can't take it back but you can't acknowledge it either since that makes it clear that you "work" is simply irrelevant to the halting problem. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-28 10:36 -0500 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <HoydnUITv4Dxq878nZ2dnUU7-LvNnZ2d@giganews.com> |
| In reply to | #40027 |
On 9/28/2021 10:14 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>> >>>>>> This is the key basis of my refutation of the halting theorem: >>>>> >>>>> You would have to find a logical flaw in the proofs. All of them. But >>>>> you have not even read the "proper" proof in Linz. The one that you can >>>>> understand is only presented for historical reasons. >>>> >>>> The logical flaw is that the halting theorem attempts to show that the >>>> halting problem is undecidable by a counter-example that is clearly >>>> decidable as non-halting. >>> But first you changed the definition of halting: >>> "This definition of halting circumvents the pathological >>> self-reference error for every simulating halt decider: >>> An input is decided to be halting only if its simulation never needs >>> to be stopped by any simulating halt decider anywhere in its entire >>> invocation chain." >>> The result is that you are no longer talking the halting problem. It's >>> a new problem: the Peter Olcott Other Halting problem where a decider >>> that rejects some halting computation is "correct". >>> "On that basis" (you go on to say): >>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>> clearly showing H rejecting a halting computation. You are admirably >>> clear. To avoid the problem present in the proof, you redefine halting >>> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >>> >>>>>> All of the "rebuttals" have taken the form of the strawman error: >>>>>> The halting theorem does not specify a simulating halt decider. >>>>>> This is no actual rebuttal to the original claim at all. >>>>> >>>>> No, the rebuttals start with a simple fact: false is not the correct >>>>> answer for a halting computation. The rest of the rebuttal comes from >>>>> you (it has to since you are carefully hiding the code): >>> You cut the part where I quote you acknowledging that >>> Halts(Confound_Halts, Confound_Halts) returns false despite >>> Confound_Halts(Confound_Halts) being a finite computation. >>> But no matter, it was there about TMs in 2017: >>> On that basis >>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>> "That basis" being "the other kind of halting that does not mean >>> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). > > It's extraordinary that you complain that no one ever points out errors, > or that there arguments are all straw men, but when it's clearly pointed > out to you, using your own posts, you have nothing to say! Not a word. > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. The halt decider does not decide that halt status of itself. The halt decider decides the halt status of its input. The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. Since you already know these things are true denying them is dishonest. Some people are confused and believe that they are pointing out errors and some people use the dishonest dodge tactic of the strawman error to fool others into believing that they pointed out errors. Of recent reviews the only thing that can be reasonably construed as any sort of error is that my current implementation is probably not based on a computable function because it currently requires static local data to derive its result. This shortcoming has its architectural design complete for more than a week. The detailed design it also almost complete. It turns out that implementing the complete Linz template where Ĥ copies its input make the halt deciding algorithm much simpler and is most naturally implemented as a pure function. https://en.wikipedia.org/wiki/Pure_function > You can't say anything because rule 1 of crank posting is to never > retract anything significant. You can't take it back but you can't > acknowledge it either since that makes it clear that you "work" is > simply irrelevant to the halting problem. > -- 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-28 19:09 -0400 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <RgN4J.43371$gc3.29971@fx12.iad> |
| In reply to | #40031 |
On 9/28/21 11:36 AM, olcott wrote: > On 9/28/2021 10:14 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>>>> This is the key basis of my refutation of the halting theorem: >>>>>> >>>>>> You would have to find a logical flaw in the proofs. All of >>>>>> them. But >>>>>> you have not even read the "proper" proof in Linz. The one that >>>>>> you can >>>>>> understand is only presented for historical reasons. >>>>> >>>>> The logical flaw is that the halting theorem attempts to show that the >>>>> halting problem is undecidable by a counter-example that is clearly >>>>> decidable as non-halting. >>>> But first you changed the definition of halting: >>>> "This definition of halting circumvents the pathological >>>> self-reference error for every simulating halt decider: >>>> An input is decided to be halting only if its simulation never >>>> needs >>>> to be stopped by any simulating halt decider anywhere in its entire >>>> invocation chain." >>>> The result is that you are no longer talking the halting problem. It's >>>> a new problem: the Peter Olcott Other Halting problem where a decider >>>> that rejects some halting computation is "correct". >>>> "On that basis" (you go on to say): >>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>> clearly showing H rejecting a halting computation. You are admirably >>>> clear. To avoid the problem present in the proof, you redefine halting >>>> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >>>> >>>>>>> All of the "rebuttals" have taken the form of the strawman error: >>>>>>> The halting theorem does not specify a simulating halt decider. >>>>>>> This is no actual rebuttal to the original claim at all. >>>>>> >>>>>> No, the rebuttals start with a simple fact: false is not the correct >>>>>> answer for a halting computation. The rest of the rebuttal comes >>>>>> from >>>>>> you (it has to since you are carefully hiding the code): >>>> You cut the part where I quote you acknowledging that >>>> Halts(Confound_Halts, Confound_Halts) returns false despite >>>> Confound_Halts(Confound_Halts) being a finite computation. >>>> But no matter, it was there about TMs in 2017: >>>> On that basis >>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>> "That basis" being "the other kind of halting that does not mean >>>> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). >> >> It's extraordinary that you complain that no one ever points out errors, >> or that there arguments are all straw men, but when it's clearly pointed >> out to you, using your own posts, you have nothing to say! Not a word. >> > > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ > if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and > > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn > if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt > > The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. > The halt decider does not decide that halt status of itself. > The halt decider decides the halt status of its input. > The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. > Reread Linz. It NEVER says 'Simulated ...' anywhere. It always refers to if P applied to I or M applied to w or what ever symbols that copy is using. It is ALWAYS the TURING MACHINE applied to ite INPUT. > Since you already know these things are true denying them is dishonest. You are right about this, but have the wrong target, it has been pointed out to you enough times that either you are mentally deficient or a pathological Liar. > > Some people are confused and believe that they are pointing out errors > and some people use the dishonest dodge tactic of the strawman error to > fool others into believing that they pointed out errors. YOU do the dishonest dodge and the straw man. > > Of recent reviews the only thing that can be reasonably construed as any > sort of error is that my current implementation is probably not based on > a computable function because it currently requires static local data to > derive its result. No, it is construed that because you claim to copies give different answers. > > This shortcoming has its architectural design complete for more than a > week. The detailed design it also almost complete. It turns out that > implementing the complete Linz template where Ĥ copies its input make > the halt deciding algorithm much simpler and is most naturally > implemented as a pure function. > > https://en.wikipedia.org/wiki/Pure_function > >> You can't say anything because rule 1 of crank posting is to never >> retract anything significant. You can't take it back but you can't >> acknowledge it either since that makes it clear that you "work" is >> simply irrelevant to the halting problem. >> > >
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-29 02:14 +0100 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <87o88cp4i3.fsf@bsb.me.uk> |
| In reply to | #40031 |
olcott <NoOne@NoWhere.com> writes: > On 9/28/2021 10:14 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>>>> This is the key basis of my refutation of the halting theorem: >>>>>> >>>>>> You would have to find a logical flaw in the proofs. All of them. But >>>>>> you have not even read the "proper" proof in Linz. The one that you can >>>>>> understand is only presented for historical reasons. >>>>> >>>>> The logical flaw is that the halting theorem attempts to show that the >>>>> halting problem is undecidable by a counter-example that is clearly >>>>> decidable as non-halting. >>>> But first you changed the definition of halting: >>>> "This definition of halting circumvents the pathological >>>> self-reference error for every simulating halt decider: >>>> An input is decided to be halting only if its simulation never needs >>>> to be stopped by any simulating halt decider anywhere in its entire >>>> invocation chain." >>>> The result is that you are no longer talking the halting problem. It's >>>> a new problem: the Peter Olcott Other Halting problem where a decider >>>> that rejects some halting computation is "correct". >>>> "On that basis" (you go on to say): >>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>> clearly showing H rejecting a halting computation. You are admirably >>>> clear. To avoid the problem present in the proof, you redefine halting >>>> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >>>> >>>>>>> All of the "rebuttals" have taken the form of the strawman error: >>>>>>> The halting theorem does not specify a simulating halt decider. >>>>>>> This is no actual rebuttal to the original claim at all. >>>>>> >>>>>> No, the rebuttals start with a simple fact: false is not the correct >>>>>> answer for a halting computation. The rest of the rebuttal comes from >>>>>> you (it has to since you are carefully hiding the code): >>>> You cut the part where I quote you acknowledging that >>>> Halts(Confound_Halts, Confound_Halts) returns false despite >>>> Confound_Halts(Confound_Halts) being a finite computation. >>>> But no matter, it was there about TMs in 2017: >>>> On that basis >>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>> "That basis" being "the other kind of halting that does not mean >>>> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). >> It's extraordinary that you complain that no one ever points out errors, >> or that there arguments are all straw men, but when it's clearly pointed >> out to you, using your own posts, you have nothing to say! Not a word. Not a word about having switched from talking about the halting problem to talking about your POOH problem. Re-defining the term "halting" so the wrong answer: H(<Ĥ>,<Ĥ>) ⊢* H.qn Ĥ(<Ĥ>) ⊢* Ĥ.qn is called "correct". You have been clear about this time and time again. Your code sketch of Halts was correct because of what would happen if line 15 were commented out. False is the correct answer for some halting computations because they only halt for a reason you consider special. This switch in the problem is not hidden. You are explicit about it. The deception all comes about in trying to pretend that is this what Linz was talking about. No. Linz was talking about actual halting: H(<Ĥ>,<Ĥ>) ⊢* H.qn iff and only if Ĥ(<Ĥ>) ⊢* oo. That's why you must keep lying about Linz's Ĥ like this: > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ > if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and > > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn > if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt You must remove Linz's correct annotations and replace them with your junk ones to try to hint that you are talking about an Ĥ like Linz's. > The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. > The halt decider does not decide that halt status of itself. > The halt decider decides the halt status of its input. > The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. > > Since you already know these things are true denying them is > dishonest. It's possible you are so confused that you think these things explain why you've removed Linz's correct description of the behaviour of Ĥ. But, one way or another, you are being deceptive and I can't do anything but call you out on it. I'm happy to help if you genuinely don't follow what Linz concludes about the behaviour of Ĥ, but your track record in understand these things is very poor. > Some people are confused and believe that they are pointing out errors > and some people use the dishonest dodge tactic of the strawman error > to fool others into believing that they pointed out errors. That's for others to judge. I quote you explicitly replacing halting with your own silly criterion and then stating, clear as day, that H is correct to reject at least one halting computation: "On that basis Ĥ(<Ĥ>) ⊢* Ĥ.qn H(<Ĥ>,<Ĥ>) ⊢* H.qn" I am confident that no intelligent reader will call this a strawman. It's the simplest possible summary of why you are not addressing the theorem you are so obsessed about. But since you are just making up your own "Peter Olcott Other Halting" problem, it's not really an error. It's not even an error to replace Linz's correct annotations about the behaviour of Ĥ with your own because, technically, you are no longer talking about Linz H/Ĥ pair anymore. It's more about deception and dishonesty than it about errors. If you didn't try to pretend that your POOH problem is just the same as the halting problem, we could all simply ignore your posts since no one cares about POOH. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-28 20:20 -0500 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <d7qdnTSvBu3FIs78nZ2dnUU7-WXNnZ2d@giganews.com> |
| In reply to | #40054 |
On 9/28/2021 8:14 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/28/2021 10:14 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>>>> This is the key basis of my refutation of the halting theorem: >>>>>>> >>>>>>> You would have to find a logical flaw in the proofs. All of them. But >>>>>>> you have not even read the "proper" proof in Linz. The one that you can >>>>>>> understand is only presented for historical reasons. >>>>>> >>>>>> The logical flaw is that the halting theorem attempts to show that the >>>>>> halting problem is undecidable by a counter-example that is clearly >>>>>> decidable as non-halting. >>>>> But first you changed the definition of halting: >>>>> "This definition of halting circumvents the pathological >>>>> self-reference error for every simulating halt decider: >>>>> An input is decided to be halting only if its simulation never needs >>>>> to be stopped by any simulating halt decider anywhere in its entire >>>>> invocation chain." >>>>> The result is that you are no longer talking the halting problem. It's >>>>> a new problem: the Peter Olcott Other Halting problem where a decider >>>>> that rejects some halting computation is "correct". >>>>> "On that basis" (you go on to say): >>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>> clearly showing H rejecting a halting computation. You are admirably >>>>> clear. To avoid the problem present in the proof, you redefine halting >>>>> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >>>>> >>>>>>>> All of the "rebuttals" have taken the form of the strawman error: >>>>>>>> The halting theorem does not specify a simulating halt decider. >>>>>>>> This is no actual rebuttal to the original claim at all. >>>>>>> >>>>>>> No, the rebuttals start with a simple fact: false is not the correct >>>>>>> answer for a halting computation. The rest of the rebuttal comes from >>>>>>> you (it has to since you are carefully hiding the code): >>>>> You cut the part where I quote you acknowledging that >>>>> Halts(Confound_Halts, Confound_Halts) returns false despite >>>>> Confound_Halts(Confound_Halts) being a finite computation. >>>>> But no matter, it was there about TMs in 2017: >>>>> On that basis >>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>> "That basis" being "the other kind of halting that does not mean >>>>> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). >>> It's extraordinary that you complain that no one ever points out errors, >>> or that there arguments are all straw men, but when it's clearly pointed >>> out to you, using your own posts, you have nothing to say! Not a word. > > Not a word about having switched from talking about the halting problem > to talking about your POOH problem. Re-defining the term "halting" so > the wrong answer: > > H(<Ĥ>,<Ĥ>) ⊢* H.qn > Ĥ(<Ĥ>) ⊢* Ĥ.qn > > is called "correct". You have been clear about this time and time > again. Your code sketch of Halts was correct because of what would > happen if line 15 were commented out. False is the correct answer for > some halting computations because they only halt for a reason you > consider special. > > This switch in the problem is not hidden. You are explicit about it. > The deception all comes about in trying to pretend that is this what > Linz was talking about. No. Linz was talking about actual halting: > > H(<Ĥ>,<Ĥ>) ⊢* H.qn iff and only if Ĥ(<Ĥ>) ⊢* oo. > > That's why you must keep lying about Linz's Ĥ like this: > >> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt > > You must remove Linz's correct annotations and replace them with your > junk ones to try to hint that you are talking about an Ĥ like Linz's. > >> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. >> The halt decider does not decide that halt status of itself. >> The halt decider decides the halt status of its input. >> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. >> >> Since you already know these things are true denying them is >> dishonest. > > It's possible you are so confused that you think these things explain > why you've removed Linz's correct description of the behaviour of Ĥ. > But, one way or another, you are being deceptive and I can't do anything > but call you out on it. I'm happy to help if you genuinely don't follow > what Linz concludes about the behaviour of Ĥ, but your track record in > understand these things is very poor. > >> Some people are confused and believe that they are pointing out errors >> and some people use the dishonest dodge tactic of the strawman error >> to fool others into believing that they pointed out errors. > > That's for others to judge. I quote you explicitly replacing halting > with your own silly criterion and then stating, clear as day, that H is > correct to reject at least one halting computation: > > "On that basis > Ĥ(<Ĥ>) ⊢* Ĥ.qn > H(<Ĥ>,<Ĥ>) ⊢* H.qn" > > I am confident that no intelligent reader will call this a strawman. > It's the simplest possible summary of why you are not addressing the > theorem you are so obsessed about. > > But since you are just making up your own "Peter Olcott Other Halting" > problem, it's not really an error. It's not even an error to replace > Linz's correct annotations about the behaviour of Ĥ with your own > because, technically, you are no longer talking about Linz H/Ĥ pair > anymore. It's more about deception and dishonesty than it about > errors. If you didn't try to pretend that your POOH problem is just the > same as the halting problem, we could all simply ignore your posts since > no one cares about POOH. > This seems to be over your head: H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 11 of 12 — ← Prev page 1 … 9 10 [11] 12 Next page →
Back to top | Article view | comp.theory
csiph-web