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 9 of 12 — ← Prev page 1 … 7 8 [9] 10 11 12 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 12:14 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <taqdnaolBqCNYcz8nZ2dnUU7-TWdnZ2d@giganews.com> |
| In reply to | #39971 |
On 9/27/2021 12:05 PM, Jeff Barnett wrote: > On 9/27/2021 8:19 AM, olcott wrote: >> On 9/27/2021 12:15 AM, Jeff Barnett wrote: >>> On 9/26/2021 10:31 PM, olcott wrote: >>>> On 9/26/2021 10:56 PM, André G. Isaak wrote: > <CRAP DELETED> >>>> >>>> So then maybe you are stupid or ignorant, The actual code itself >>>> cycles from 0xc36 though 0xc41 an infinite number of times unless >>>> H(P,P) aborts the simulation of its input. In that case the >>>> simulation is cut off at 0xc41. In no case does this code reach >>>> final state 0xc50. >>> >>> <CRAP DELETED> >>> >>> So you now admit that your x86 simulator is flawed? Or maybe it >>> isn't, but you set it up wrong or are using it incorrectly? You need >>> to do something other than software; you're just not very good at it >>> you know. Working in an area where you are inadequate causes you to >>> act like a bad person out of frustration. Here you are calling Andre >>> stupid and ignorant for trying to help you and make you better. You >>> should say "thank you" instead of being such a crappy person. You >>> should change your area of study to something simple like cooking >>> rice. A few successes would improve your self image and stop the name >>> calling and tantrums. You are no longer 3 years old. Time to mature a >>> little. >> >> You are a clueless wonder that only has utterly baseless nay saying. > > More name calling; so out of control. a recapitulation of the "terrible > threes". Concentrate; control yourself; be grateful for help offered to > you. Time's short; strive for adulthood now. We are all rooting for you. > Give life as an adult a chance while you have that opportunity. Good luck. That you are a clueless wonder relative to your utterly baseless nay saying about my work is self-evidently true to anyone having sufficient understanding of the underlying subject matter. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2021-09-27 11:52 -0600 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <sit0cv$3hi$1@dont-email.me> |
| In reply to | #39973 |
On 9/27/2021 11:14 AM, olcott wrote: > On 9/27/2021 12:05 PM, Jeff Barnett wrote: >>> You are a clueless wonder that only has utterly baseless nay saying. >> >> More name calling; so out of control. a recapitulation of the >> "terrible threes". Concentrate; control yourself; be grateful for help >> offered to you. Time's short; strive for adulthood now. We are all >> rooting for you. Give life as an adult a chance while you have that >> opportunity. Good luck. > > That you are a clueless wonder relative to your utterly baseless nay > saying about my work is self-evidently true to anyone having sufficient > understanding of the underlying subject matter. You are in a loop, just like your ill-conceived simulator. Do give life as an adult a chance. Life only gives us limited opportunities to do better. Carpe diem! And best of luck with adulthood; we are all rooting for you. -- Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 13:08 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <VLudnRfaIu41lc_8nZ2dnUU7-c_NnZ2d@giganews.com> |
| In reply to | #39975 |
On 9/27/2021 12:52 PM, Jeff Barnett wrote: > On 9/27/2021 11:14 AM, olcott wrote: >> On 9/27/2021 12:05 PM, Jeff Barnett wrote: >>>> You are a clueless wonder that only has utterly baseless nay saying. >>> >>> More name calling; so out of control. a recapitulation of the >>> "terrible threes". Concentrate; control yourself; be grateful for >>> help offered to you. Time's short; strive for adulthood now. We are >>> all rooting for you. Give life as an adult a chance while you have >>> that opportunity. Good luck. >> >> That you are a clueless wonder relative to your utterly baseless nay >> saying about my work is self-evidently true to anyone having >> sufficient understanding of the underlying subject matter. > > You are in a loop, just like your ill-conceived simulator. Do give life > as an adult a chance. Life only gives us limited opportunities to do > better. Carpe diem! And best of luck with adulthood; we are all rooting > for you. This is the key basis of my refutation of the halting theorem: The halting theorem counter-examples present infinitely nested simulation (non-halting) behavior to every simulating halt decider. 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. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 12:41 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <IZudnYjB1fr4n8_8nZ2dnUU7-X_NnZ2d@giganews.com> |
| In reply to | #39971 |
On 9/27/2021 12:05 PM, Jeff Barnett wrote:
> On 9/27/2021 8:19 AM, olcott wrote:
>> On 9/27/2021 12:15 AM, Jeff Barnett wrote:
>>> On 9/26/2021 10:31 PM, olcott wrote:
>>>> On 9/26/2021 10:56 PM, André G. Isaak wrote:
> <CRAP DELETED>
>>>>
>>>> So then maybe you are stupid or ignorant, The actual code itself
>>>> cycles from 0xc36 though 0xc41 an infinite number of times unless
>>>> H(P,P) aborts the simulation of its input. In that case the
>>>> simulation is cut off at 0xc41. In no case does this code reach
>>>> final state 0xc50.
>>>
>>> <CRAP DELETED>
>>>
>>> So you now admit that your x86 simulator is flawed? Or maybe it
>>> isn't, but you set it up wrong or are using it incorrectly? You need
>>> to do something other than software; you're just not very good at it
>>> you know. Working in an area where you are inadequate causes you to
>>> act like a bad person out of frustration. Here you are calling Andre
>>> stupid and ignorant for trying to help you and make you better. You
>>> should say "thank you" instead of being such a crappy person. You
>>> should change your area of study to something simple like cooking
>>> rice. A few successes would improve your self image and stop the name
>>> calling and tantrums. You are no longer 3 years old. Time to mature a
>>> little.
>>
>> You are a clueless wonder that only has utterly baseless nay saying.
>
> More name calling; so out of control. a recapitulation of the "terrible
> threes". Concentrate; control yourself; be grateful for help offered to
> you. Time's short; strive for adulthood now. We are all rooting for you.
> Give life as an adult a chance while you have that opportunity. Good luck.
You are the only one with utterly baseless critique of my work. The only
critique of the {essence of my work} that has not been baseless has been
the key issue of what is required for a C function to meet the standard
of the theory of computation computable function.
There have been numerous times when I used a technical term of the art
in ways that slightly differ from their conventional meaning. Some of
these times may be accurately construed as errors. Some of these times
are cases where the term of the art was the closest approximation to the
meaning that I intended thus not exactly an actual error. Imprecise use
of terms of the art may reduce my credibility yet has no impact
what-so-ever on the validity of the essence of my work.
It is true that without the reviews of my work on comp.theory that my
work would have never been completed. This deserves gratitude to the
reviewers of my work on comp.theory. Even though what these reviewers
presented as an error was almost never any actual error at all these
reviews did help me increasingly clarify my position to best address
objections to this position.
The most exasperating critique of my work is when reviewers essentially
disagree that a {black cat} is either {black} or a {cat}.
_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
Begin Local Halt Decider Simulation at Machine Address:c36
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)
Disagreeing that the input to H(P,P) never reaches its final state of
0xc50 whether or not simulating halt decider H stops simulating its
input is one of the cases where a {black cat} is denied being either
{black} or a {cat}.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2021-09-27 12:05 -0600 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <sit150$9ge$1@dont-email.me> |
| In reply to | #39974 |
On 9/27/2021 11:41 AM, olcott wrote:
> On 9/27/2021 12:05 PM, Jeff Barnett wrote:
>> On 9/27/2021 8:19 AM, olcott wrote:
>>> On 9/27/2021 12:15 AM, Jeff Barnett wrote:
>>>> On 9/26/2021 10:31 PM, olcott wrote:
>>>>> On 9/26/2021 10:56 PM, André G. Isaak wrote:
>> <CRAP DELETED>
>>>>>
>>>>> So then maybe you are stupid or ignorant, The actual code itself
>>>>> cycles from 0xc36 though 0xc41 an infinite number of times unless
>>>>> H(P,P) aborts the simulation of its input. In that case the
>>>>> simulation is cut off at 0xc41. In no case does this code reach
>>>>> final state 0xc50.
>>>>
>>>> <CRAP DELETED>
>>>>
>>>> So you now admit that your x86 simulator is flawed? Or maybe it
>>>> isn't, but you set it up wrong or are using it incorrectly? You need
>>>> to do something other than software; you're just not very good at it
>>>> you know. Working in an area where you are inadequate causes you to
>>>> act like a bad person out of frustration. Here you are calling Andre
>>>> stupid and ignorant for trying to help you and make you better. You
>>>> should say "thank you" instead of being such a crappy person. You
>>>> should change your area of study to something simple like cooking
>>>> rice. A few successes would improve your self image and stop the
>>>> name calling and tantrums. You are no longer 3 years old. Time to
>>>> mature a little.
>>>
>>> You are a clueless wonder that only has utterly baseless nay saying.
>>
>> More name calling; so out of control. a recapitulation of the
>> "terrible threes". Concentrate; control yourself; be grateful for help
>> offered to you. Time's short; strive for adulthood now. We are all
>> rooting for you. Give life as an adult a chance while you have that
>> opportunity. Good luck.
>
> You are the only one with utterly baseless critique of my work. The only
> critique of the {essence of my work} that has not been baseless has been
> the key issue of what is required for a C function to meet the standard
> of the theory of computation computable function.
>
> There have been numerous times when I used a technical term of the art
> in ways that slightly differ from their conventional meaning. Some of
> these times may be accurately construed as errors. Some of these times
> are cases where the term of the art was the closest approximation to the
> meaning that I intended thus not exactly an actual error. Imprecise use
> of terms of the art may reduce my credibility yet has no impact
> what-so-ever on the validity of the essence of my work.
>
> It is true that without the reviews of my work on comp.theory that my
> work would have never been completed. This deserves gratitude to the
> reviewers of my work on comp.theory. Even though what these reviewers
> presented as an error was almost never any actual error at all these
> reviews did help me increasingly clarify my position to best address
> objections to this position.
>
> The most exasperating critique of my work is when reviewers essentially
> disagree that a {black cat} is either {black} or a {cat}.
>
> _P()
> [00000c36](01) 55 push ebp
> [00000c37](02) 8bec mov ebp,esp
> [00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
> [00000c3c](01) 50 push eax
> [00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
> [00000c40](01) 51 push ecx
> [00000c41](05) e820fdffff call 00000966 // call H
> [00000c46](03) 83c408 add esp,+08
> [00000c49](02) 85c0 test eax,eax
> [00000c4b](02) 7402 jz 00000c4f
> [00000c4d](02) ebfe jmp 00000c4d
> [00000c4f](01) 5d pop ebp
> [00000c50](01) c3 ret
> Size in bytes:(0027) [00000c50]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
>
> Begin Local Halt Decider Simulation at Machine Address:c36
> [00000c36][002117ca][002117ce] 55 push ebp
> [00000c37][002117ca][002117ce] 8bec mov ebp,esp
> [00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
> [00000c3c][002117c6][00000c36] 50 push eax // push P
> [00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
> [00000c40][002117c2][00000c36] 51 push ecx // push P
> [00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)
>
> Disagreeing that the input to H(P,P) never reaches its final state of
> 0xc50 whether or not simulating halt decider H stops simulating its
> input is one of the cases where a {black cat} is denied being either
> {black} or a {cat}.
You are still out of control. Ben will not let you off from specific
lies and contradictions no matter how much you try to change the
subject. I, on the other hand, will not let you off from your childish
(NB, I did not say child-like) behavior until we can see a maturation
process started. Given your off the mark, ignorant ideas and tantrums,
can you imagine how these howlers are perceived at the end of your messages:
"Copyright 2021 Pete Olcott
'Great spirits have always encountered violent opposition from
mediocre minds.' Einstein"
A copyright! I can't imagine anyone else dumb enough to write such
dribble. No not a soul. And as the king/queen of mediocrity, well can
you imagine the giggle when anyone reads it? Who do they think it's
about. Do you need a hint?
--
Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 13:31 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <J8udneU4C5mSk8_8nZ2dnUU7-cXNnZ2d@giganews.com> |
| In reply to | #39976 |
On 9/27/2021 1:05 PM, Jeff Barnett wrote:
> On 9/27/2021 11:41 AM, olcott wrote:
>> On 9/27/2021 12:05 PM, Jeff Barnett wrote:
>>> On 9/27/2021 8:19 AM, olcott wrote:
>>>> On 9/27/2021 12:15 AM, Jeff Barnett wrote:
>>>>> On 9/26/2021 10:31 PM, olcott wrote:
>>>>>> On 9/26/2021 10:56 PM, André G. Isaak wrote:
>>> <CRAP DELETED>
>>>>>>
>>>>>> So then maybe you are stupid or ignorant, The actual code itself
>>>>>> cycles from 0xc36 though 0xc41 an infinite number of times unless
>>>>>> H(P,P) aborts the simulation of its input. In that case the
>>>>>> simulation is cut off at 0xc41. In no case does this code reach
>>>>>> final state 0xc50.
>>>>>
>>>>> <CRAP DELETED>
>>>>>
>>>>> So you now admit that your x86 simulator is flawed? Or maybe it
>>>>> isn't, but you set it up wrong or are using it incorrectly? You
>>>>> need to do something other than software; you're just not very good
>>>>> at it you know. Working in an area where you are inadequate causes
>>>>> you to act like a bad person out of frustration. Here you are
>>>>> calling Andre stupid and ignorant for trying to help you and make
>>>>> you better. You should say "thank you" instead of being such a
>>>>> crappy person. You should change your area of study to something
>>>>> simple like cooking rice. A few successes would improve your self
>>>>> image and stop the name calling and tantrums. You are no longer 3
>>>>> years old. Time to mature a little.
>>>>
>>>> You are a clueless wonder that only has utterly baseless nay saying.
>>>
>>> More name calling; so out of control. a recapitulation of the
>>> "terrible threes". Concentrate; control yourself; be grateful for
>>> help offered to you. Time's short; strive for adulthood now. We are
>>> all rooting for you. Give life as an adult a chance while you have
>>> that opportunity. Good luck.
>>
>> You are the only one with utterly baseless critique of my work. The
>> only critique of the {essence of my work} that has not been baseless
>> has been the key issue of what is required for a C function to meet
>> the standard of the theory of computation computable function.
>>
>> There have been numerous times when I used a technical term of the art
>> in ways that slightly differ from their conventional meaning. Some of
>> these times may be accurately construed as errors. Some of these times
>> are cases where the term of the art was the closest approximation to
>> the meaning that I intended thus not exactly an actual error.
>> Imprecise use of terms of the art may reduce my credibility yet has no
>> impact what-so-ever on the validity of the essence of my work.
>>
>> It is true that without the reviews of my work on comp.theory that my
>> work would have never been completed. This deserves gratitude to the
>> reviewers of my work on comp.theory. Even though what these reviewers
>> presented as an error was almost never any actual error at all these
>> reviews did help me increasingly clarify my position to best address
>> objections to this position.
>>
>> The most exasperating critique of my work is when reviewers
>> essentially disagree that a {black cat} is either {black} or a {cat}.
>>
>> _P()
>> [00000c36](01) 55 push ebp
>> [00000c37](02) 8bec mov ebp,esp
>> [00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
>> [00000c3c](01) 50 push eax
>> [00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
>> [00000c40](01) 51 push ecx
>> [00000c41](05) e820fdffff call 00000966 // call H
>> [00000c46](03) 83c408 add esp,+08
>> [00000c49](02) 85c0 test eax,eax
>> [00000c4b](02) 7402 jz 00000c4f
>> [00000c4d](02) ebfe jmp 00000c4d
>> [00000c4f](01) 5d pop ebp
>> [00000c50](01) c3 ret
>> Size in bytes:(0027) [00000c50]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>>
>> Begin Local Halt Decider Simulation at Machine Address:c36
>> [00000c36][002117ca][002117ce] 55 push ebp
>> [00000c37][002117ca][002117ce] 8bec mov ebp,esp
>> [00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
>> [00000c3c][002117c6][00000c36] 50 push eax // push P
>> [00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
>> [00000c40][002117c2][00000c36] 51 push ecx // push P
>> [00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)
>>
>> Disagreeing that the input to H(P,P) never reaches its final state of
>> 0xc50 whether or not simulating halt decider H stops simulating its
>> input is one of the cases where a {black cat} is denied being either
>> {black} or a {cat}.
>
> You are still out of control. Ben will not let you off from specific
> lies and contradictions no matter how much you try to change the
> subject.
This is the key basis of my refutation of the halting theorem:
The halting theorem counter-examples present infinitely nested
simulation (non-halting) behavior to every simulating halt decider.
I presented this to Ben more than four years ago and he successfully
changed the subject with various dishonest dodges so that it could not
be properly evaluated until now.
Infinitely Recursive input on HP Proofs
peteolcott
Mar 11, 2017, 3:13:03 PM
https://groups.google.com/g/comp.theory/c/NcFS02hKs1U
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.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2021-09-27 12:53 -0600 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <sit40a$upf$1@dont-email.me> |
| In reply to | #39979 |
On 9/27/2021 12:31 PM, olcott wrote:
<CRAP SNAP>
> This is the key basis of my refutation of the halting theorem:
> The halting theorem counter-examples present infinitely nested
> simulation (non-halting) behavior to every simulating halt decider.
>
> I presented this to Ben more than four years ago and he successfully
> changed the subject with various dishonest dodges so that it could not
> be properly evaluated until now.
>
> Infinitely Recursive input on HP Proofs
> peteolcott
> Mar 11, 2017, 3:13:03 PM
> https://groups.google.com/g/comp.theory/c/NcFS02hKs1U
>
> 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 one but you has been dishonest. And that is a two decade truth. If
Martin Davis or Peter Lintz said they now had doubt of the halting
theorem, the world would be excited. We would expect to learn something
new about model theory or a new theory of computation. Also, most of us
would be a little sad: Since this was an extremely well pawed over area,
we would expect the insight to occur at such a deep level that we may or
may not be able to enjoy it either through lack of ability or of
knowledge at the state of the art. You, on the other hand are repeating
problems first discussed and analyzed by the pre Greeks. Today, the liar
paradox is for the amusement of school children, not logicians or
mathematicians. You are several thousand years late. The issues which
drive you are the stuff of Penny Problem Solver collections. There is a
book called "What is the name of this book?". Get a copy and read it
while there is time.
In any event, stop this childish repetition of non sense. Give adulthood
a chance. We are not all destined for fame and immortality for our brain
power. It's certain you are not. Even if your brain was adequate to do
world class work, your personality disorders disqualify you. You refuse
to listen, you refuse to learn, and you throw constant tantrums. The
technical world is much too sophisticated for a genius to walk in off
the streets and present a new earth shaking method to bake bread, let
alone do a new computation theory. You really do need to study more and
learn from the masters.
Your current plan has made you appear (and be) a classic case of
ignorance morphed into stupidity. You need to grow up.
Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 14:07 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <_bidnQSYRcPsi8_8nZ2dnUU7-RXNnZ2d@giganews.com> |
| In reply to | #39980 |
On 9/27/2021 1:53 PM, Jeff Barnett wrote: > On 9/27/2021 12:31 PM, olcott wrote: > <CRAP SNAP> > >> This is the key basis of my refutation of the halting theorem: >> The halting theorem counter-examples present infinitely nested >> simulation (non-halting) behavior to every simulating halt decider. >> >> I presented this to Ben more than four years ago and he successfully >> changed the subject with various dishonest dodges so that it could not >> be properly evaluated until now. >> >> Infinitely Recursive input on HP Proofs >> peteolcott >> Mar 11, 2017, 3:13:03 PM >> https://groups.google.com/g/comp.theory/c/NcFS02hKs1U >> >> 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 one but you has been dishonest. I triple dog dare you to show how the above key basis of my refutation is incorrect. https://www.youtube.com/watch?v=ZLZj3zOUZNs -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-27 20:52 +0100 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <87h7e5u775.fsf@bsb.me.uk> |
| In reply to | #39979 |
olcott <NoOne@NoWhere.com> writes: > This is the key basis of my refutation of the halting theorem: > The halting theorem counter-examples present infinitely nested > simulation (non-halting) behavior to every simulating halt decider. This is one reason a simulator can't be a halt decider. Of course you know this, which is why your putative decider is not a simulator but a partial simulator. It too fails to be a halt decider, as does every Turing machine. That's why you must declare false to be the correct answer for some halting computations. > 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 fact that a simulator can't be a halt decider (and there are more reasons for that than the one you cite above) does not show a flaw in any proof. > 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): "Halts(Confound_Halts, Confound_Halts) returns false." Message-ID: <2aidnV9e3qQaOCDCnZ2dnUU7-c3NnZ2d@giganews.com> and "The input to Halts is only finite because..." Message-ID: <6eSdnYuLBrIuVFzCnZ2dnUU7-cPNnZ2d@giganews.com> Your wording is poor, but you've been very clear about what you mean: computations that "only" halt for reasons you consider "special" can be declared non-halting. This is not what the halting problem is about[1]. You have nothing at all, but you have told some very grandiose lies, and insulted a lot of people along the way and I think that's what really matters to you. [1] Ironically, this Peter Olcott "Other Halting problem" is also undecidable, given the definition you often give for the "special" reasons. So you don't even have a POOH decider. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 15:44 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <Gb6dnd4FDLS0sM_8nZ2dnUU7-IXNnZ2d@giganews.com> |
| In reply to | #39983 |
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: >> The halting theorem counter-examples present infinitely nested >> simulation (non-halting) behavior to every simulating halt decider. > > This is one reason a simulator can't be a halt decider. Of course you know that I am net talking about a simulator being used as it it was a halt decider thus your reply is the same dishonest dodge intentional (thus dishonest) strawman error as always. > Of course you > know this, which is why your putative decider is not a simulator but a > partial simulator. It too fails to be a halt decider, as does every > Turing machine. That's why you must declare false to be the correct > answer for some halting computations. > >> 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. > The fact that a simulator can't be a halt decider (and there are more > reasons for that than the one you cite above) does not show a flaw in > any proof. > Of course a simulator cannot by itself be a halt decider and it is ridiculously dishonest of you to imply that this is what I mean. >> 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): > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // because the simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by Ĥ.qx DOES NOT HALT The computation of Ĥ applied to ⟨Ĥ⟩ is a distinctly different computation than the computation of the simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by Ĥ.qx. If we want to specify a computation that is equivalent to Ĥ applied to ⟨Ĥ⟩ we must specify H applied to ⟨Ĥ⟩ ⟨Ĥ⟩. H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy The difference is that the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ invokes a copy of Ĥ.qx whereas the input to H does not invoke a copy of H. The pathological self-reference error that I first discovered in 2004 is the key to finally resolved these otherwise undecidable decision problem inputs. comp.theory Halting Problem Final Conclusion Peter Olcott Sep 5, 2004, The Liar Paradox can be shown to be nothing more than a incorrectly formed statement because of its pathological self-reference. The Halting Problem can only exist because of this same sort of pathological self-reference. https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-28 02:45 +0100 |
| Subject | 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 | <877df1scav.fsf_-_@bsb.me.uk> |
| In reply to | #39986 |
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 You have defined the "basis" on which rejecting a halting computation is "correct" so the specification is now easy to meet. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 21:05 -0500 |
| 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 | <F5CdnaQUNenj5c_8nZ2dnUU7-cPNnZ2d@giganews.com> |
| In reply to | #40000 |
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 ⟨Ĥ⟩ ⟨Ĥ⟩ The halt decider is not at Ĥ.q0 it is at Ĥ.qx 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 ⟨Ĥ⟩. -- 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-27 20:40 -0600 |
| 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 | <sitvb7$iia$1@dont-email.me> |
| In reply to | #40003 |
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. So of course H(H_Hat, H_Hat) is being asked whether H_Hat(H_Hat) halts. It doesn't matter whether your H works by simulating or by some other more sensible means. The question is about the behaviour of the actual Turing Machine H_Hat applied to a description of H_Hat. That you think a 'description of a computation' could possibly refer to anything other than the independent computation being described is truly mystifying. Why would anyone possibly care about what happens in some simulation if that simulation doesn't reflect the behaviour of the actual computation described? If you don't grasp this, then you don't even understand the problem which the Linz proof is concerned with. If you don't understand the problem, how can you possibly understand the proof, let alone 'refute' it? 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-27 21:52 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <1vOdncXXw_nkHs_8nZ2dnUU7-YHNnZ2d@giganews.com> |
| In reply to | #40006 |
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. H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is computationally equivalent to Ĥ applied to ⟨Ĥ⟩. Ĥ applied to ⟨Ĥ⟩ is NOT computationally equivalent to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩. 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. Olcott C/x86 H and H1 are being transformed into pure functions. https://en.wikipedia.org/wiki/Pure_function I do not expect that the results will change. > So of course H(H_Hat, H_Hat) is being asked whether H_Hat(H_Hat) halts. > It doesn't matter whether your H works by simulating or by some other > more sensible means. The question is about the behaviour of the actual > Turing Machine H_Hat applied to a description of H_Hat. > > That you think a 'description of a computation' could possibly refer to > anything other than the independent computation being described is truly > mystifying. Why would anyone possibly care about what happens in some > simulation if that simulation doesn't reflect the behaviour of the > actual computation described? > > If you don't grasp this, then you don't even understand the problem > which the Linz proof is concerned with. If you don't understand the > problem, how can you possibly understand the proof, let alone 'refute' it? > > 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-27 21:14 -0600 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <siu1bl$t2e$1@dont-email.me> |
| In reply to | #40008 |
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é -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 22:28 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <PKGdnfCNfZVRFs_8nZ2dnUU7-I_NnZ2d@giganews.com> |
| In reply to | #40010 |
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 ⟨Ĥ⟩ ⟨Ĥ⟩. 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. -- 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 23:35 -0400 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <%3w4J.54673$6U3.18515@fx43.iad> |
| In reply to | #40011 |
On 9/27/21 11:28 PM, 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 ⟨Ĥ⟩ ⟨Ĥ⟩. > > 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. > > Only if the Halt Decider isn't a computation, and thus not really a decider. A Computation *ALWAYS* returns the same answer for the same input, in EVERY Case. P(I) needs to ALWAYS return the same answer, even if P works in part by simulating part of its input, and that input includes a copy of P. There is not 'recursive' exception to the definition of a computation. THus if H1 and H are REALLY the exact same algorithm (so equivalent Turing Machines) H1(P,I) must always give the same answer as H(P,I) If they give different answers, they aren't the same machine.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 22:46 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <9LGdnfDaitqeDc_8nZ2dnUU7-NnNnZ2d@giganews.com> |
| In reply to | #40012 |
On 9/27/2021 10:35 PM, Richard Damon wrote:
> On 9/27/21 11:28 PM, 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 ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> 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.
>>
>>
>
> Only if the Halt Decider isn't a computation, and thus not really a decider.
>
> A Computation *ALWAYS* returns the same answer for the same input, in
> EVERY Case.
>
> P(I) needs to ALWAYS return the same answer, even if P works in part by
> simulating part of its input, and that input includes a copy of P.
>
> There is not 'recursive' exception to the definition of a computation.
>
> THus if H1 and H are REALLY the exact same algorithm (so equivalent
> Turing Machines) H1(P,I) must always give the same answer as H(P,I)
>
> If they give different answers, they aren't the same machine.
>
Once the halt status "impossible" input has been correctly decided prior
false assumptions about these things will be required to change.
If any problem is studied to a much greater extent that anyone has ever
studied it before brand new insights become possible.
I use the same {first principles} method that Elon Musk uses:
https://jamesclear.com/first-principles
--
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 06:27 -0400 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <16C4J.16074$_n1.1710@fx14.iad> |
| In reply to | #40013 |
On 9/27/21 11:46 PM, olcott wrote:
> On 9/27/2021 10:35 PM, Richard Damon wrote:
>> On 9/27/21 11:28 PM, 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
>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> 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.
>>>
>>>
>>
>> Only if the Halt Decider isn't a computation, and thus not really a
>> decider.
>>
>> A Computation *ALWAYS* returns the same answer for the same input, in
>> EVERY Case.
>>
>> P(I) needs to ALWAYS return the same answer, even if P works in part by
>> simulating part of its input, and that input includes a copy of P.
>>
>> There is not 'recursive' exception to the definition of a computation.
>>
>> THus if H1 and H are REALLY the exact same algorithm (so equivalent
>> Turing Machines) H1(P,I) must always give the same answer as H(P,I)
>>
>> If they give different answers, they aren't the same machine.
>>
>
> Once the halt status "impossible" input has been correctly decided prior
> false assumptions about these things will be required to change.
>
> If any problem is studied to a much greater extent that anyone has ever
> studied it before brand new insights become possible.
>
> I use the same {first principles} method that Elon Musk uses:
> https://jamesclear.com/first-principles
>
But, you are NOT allowed to change the definitions of what the Halt
Decider is supposed to do, like what it is answering about. PERIOD.
Just because you find that it is impossible to build a decider to its
specifications, does NOT mean that the problem is improperly defined,
and that you get to change the problem.
Maybe if you actually understood WHY the Halting Problem is defined the
way it is, it would help.
First Principles work on problems where you do understand what is
needed, but existing methodologies aren't getting there, or not efficiently.
In this case, you seem to think the goal is something like the software
concept of detecting run-away programs that are going to use up the
computer resources, but that isn't what the halting problem is about.
You 'answer' would be like Elon Musk deciding that the easy way to get
to 'Mars' would be to buy a big stretch of desolate landscape and
building a place there that he called 'Mars', and letting people pay him
to go there.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-28 09:20 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <GZCdnUmtt7EEuc78nZ2dnUU7-TfNnZ2d@giganews.com> |
| In reply to | #40019 |
On 9/28/2021 5:27 AM, Richard Damon wrote:
> On 9/27/21 11:46 PM, olcott wrote:
>> On 9/27/2021 10:35 PM, Richard Damon wrote:
>>> On 9/27/21 11:28 PM, 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
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> 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.
>>>>
>>>>
>>>
>>> Only if the Halt Decider isn't a computation, and thus not really a
>>> decider.
>>>
>>> A Computation *ALWAYS* returns the same answer for the same input, in
>>> EVERY Case.
>>>
>>> P(I) needs to ALWAYS return the same answer, even if P works in part by
>>> simulating part of its input, and that input includes a copy of P.
>>>
>>> There is not 'recursive' exception to the definition of a computation.
>>>
>>> THus if H1 and H are REALLY the exact same algorithm (so equivalent
>>> Turing Machines) H1(P,I) must always give the same answer as H(P,I)
>>>
>>> If they give different answers, they aren't the same machine.
>>>
>>
>> Once the halt status "impossible" input has been correctly decided prior
>> false assumptions about these things will be required to change.
>>
>> If any problem is studied to a much greater extent that anyone has ever
>> studied it before brand new insights become possible.
>>
>> I use the same {first principles} method that Elon Musk uses:
>> https://jamesclear.com/first-principles
>>
>
> But, you are NOT allowed to change the definitions of what the Halt
> Decider is supposed to do, like what it is answering about. PERIOD.
>
If a simulated input never reaches its own final state whether or not
the simulator simulates this input forever or aborts the simulation of
this input we can know that this simulated input never halts according
to the conventional meaning of halting.
> Just because you find that it is impossible to build a decider to its
> specifications, does NOT mean that the problem is improperly defined,
> and that you get to change the problem.
>
> Maybe if you actually understood WHY the Halting Problem is defined the
> way it is, it would help.
>
> First Principles work on problems where you do understand what is
> needed, but existing methodologies aren't getting there, or not efficiently.
>
The key aspect of first principles reasoning is to utterly discard all
assumptions and begin thinking everything through again from scratch.
I call my system categorically exhaustive reasoning by empirically
testing categories of possibilities that I have not yet proven to be
impossible using a process of elimination until I interpolate on an
optimal solution.
> In this case, you seem to think the goal is something like the software
> concept of detecting run-away programs that are going to use up the
> computer resources, but that isn't what the halting problem is about.
>
> You 'answer' would be like Elon Musk deciding that the easy way to get
> to 'Mars' would be to buy a big stretch of desolate landscape and
> building a place there that he called 'Mars', and letting people pay him
> to go there.
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 9 of 12 — ← Prev page 1 … 7 8 [9] 10 11 12 Next page →
Back to top | Article view | comp.theory
csiph-web