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 | 15 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 12 of 12 — ← Prev page 1 … 10 11 [12]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-28 22:05 -0400 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <RRP4J.151456$o45.141521@fx46.iad> |
| In reply to | #40057 |
On 9/28/21 9:20 PM, olcott wrote: > On 9/28/2021 8:14 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/28/2021 10:14 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>>>> This is the key basis of my refutation of the halting theorem: >>>>>>>> >>>>>>>> You would have to find a logical flaw in the proofs. All of >>>>>>>> them. But >>>>>>>> you have not even read the "proper" proof in Linz. The one that >>>>>>>> you can >>>>>>>> understand is only presented for historical reasons. >>>>>>> >>>>>>> The logical flaw is that the halting theorem attempts to show >>>>>>> that the >>>>>>> halting problem is undecidable by a counter-example that is clearly >>>>>>> decidable as non-halting. >>>>>> But first you changed the definition of halting: >>>>>> "This definition of halting circumvents the pathological >>>>>> self-reference error for every simulating halt decider: >>>>>> An input is decided to be halting only if its simulation >>>>>> never needs >>>>>> to be stopped by any simulating halt decider anywhere in its >>>>>> entire >>>>>> invocation chain." >>>>>> The result is that you are no longer talking the halting problem. >>>>>> It's >>>>>> a new problem: the Peter Olcott Other Halting problem where a decider >>>>>> that rejects some halting computation is "correct". >>>>>> "On that basis" (you go on to say): >>>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>>> clearly showing H rejecting a halting computation. You are admirably >>>>>> clear. To avoid the problem present in the proof, you redefine >>>>>> halting >>>>>> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >>>>>> >>>>>>>>> All of the "rebuttals" have taken the form of the strawman error: >>>>>>>>> The halting theorem does not specify a simulating halt decider. >>>>>>>>> This is no actual rebuttal to the original claim at all. >>>>>>>> >>>>>>>> No, the rebuttals start with a simple fact: false is not the >>>>>>>> correct >>>>>>>> answer for a halting computation. The rest of the rebuttal >>>>>>>> comes from >>>>>>>> you (it has to since you are carefully hiding the code): >>>>>> You cut the part where I quote you acknowledging that >>>>>> Halts(Confound_Halts, Confound_Halts) returns false despite >>>>>> Confound_Halts(Confound_Halts) being a finite computation. >>>>>> But no matter, it was there about TMs in 2017: >>>>>> On that basis >>>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>>> "That basis" being "the other kind of halting that does not mean >>>>>> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). >>>> It's extraordinary that you complain that no one ever points out >>>> errors, >>>> or that there arguments are all straw men, but when it's clearly >>>> pointed >>>> out to you, using your own posts, you have nothing to say! Not a word. >> >> Not a word about having switched from talking about the halting problem >> to talking about your POOH problem. Re-defining the term "halting" so >> the wrong answer: >> >> H(<Ĥ>,<Ĥ>) ⊢* H.qn >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> is called "correct". You have been clear about this time and time >> again. Your code sketch of Halts was correct because of what would >> happen if line 15 were commented out. False is the correct answer for >> some halting computations because they only halt for a reason you >> consider special. >> >> This switch in the problem is not hidden. You are explicit about it. >> The deception all comes about in trying to pretend that is this what >> Linz was talking about. No. Linz was talking about actual halting: >> >> H(<Ĥ>,<Ĥ>) ⊢* H.qn iff and only if Ĥ(<Ĥ>) ⊢* oo. >> >> That's why you must keep lying about Linz's Ĥ like this: >> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >> >> You must remove Linz's correct annotations and replace them with your >> junk ones to try to hint that you are talking about an Ĥ like Linz's. >> >>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. >>> The halt decider does not decide that halt status of itself. >>> The halt decider decides the halt status of its input. >>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. >>> >>> Since you already know these things are true denying them is >>> dishonest. >> >> It's possible you are so confused that you think these things explain >> why you've removed Linz's correct description of the behaviour of Ĥ. >> But, one way or another, you are being deceptive and I can't do anything >> but call you out on it. I'm happy to help if you genuinely don't follow >> what Linz concludes about the behaviour of Ĥ, but your track record in >> understand these things is very poor. >> >>> Some people are confused and believe that they are pointing out errors >>> and some people use the dishonest dodge tactic of the strawman error >>> to fool others into believing that they pointed out errors. >> >> That's for others to judge. I quote you explicitly replacing halting >> with your own silly criterion and then stating, clear as day, that H is >> correct to reject at least one halting computation: >> >> "On that basis >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> H(<Ĥ>,<Ĥ>) ⊢* H.qn" >> >> I am confident that no intelligent reader will call this a strawman. >> It's the simplest possible summary of why you are not addressing the >> theorem you are so obsessed about. >> >> But since you are just making up your own "Peter Olcott Other Halting" >> problem, it's not really an error. It's not even an error to replace >> Linz's correct annotations about the behaviour of Ĥ with your own >> because, technically, you are no longer talking about Linz H/Ĥ pair >> anymore. It's more about deception and dishonesty than it about >> errors. If you didn't try to pretend that your POOH problem is just the >> same as the halting problem, we could all simply ignore your posts since >> no one cares about POOH. >> > > This seems to be over your head: > H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ > > Then H^ is built wrong. PERIOD. FAILURE OF PROOF. The RULES for constructing H^ was to place a copy of the algorithm of H at that point. If the results is a completely different computation, you didn't follow the instructions or H isn't actually a computation so it can't be put there. If you now claim it isn't there, then YOU made the error. FAIL.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-29 23:17 +0100 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <87a6jvowl0.fsf@bsb.me.uk> |
| In reply to | #40057 |
olcott <NoOne@NoWhere.com> writes: > On 9/28/2021 8:14 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/28/2021 10:14 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>>>> This is the key basis of my refutation of the halting theorem: >>>>>>>> >>>>>>>> You would have to find a logical flaw in the proofs. All of them. But >>>>>>>> you have not even read the "proper" proof in Linz. The one that you can >>>>>>>> understand is only presented for historical reasons. >>>>>>> >>>>>>> The logical flaw is that the halting theorem attempts to show that the >>>>>>> halting problem is undecidable by a counter-example that is clearly >>>>>>> decidable as non-halting. >>>>>> But first you changed the definition of halting: >>>>>> "This definition of halting circumvents the pathological >>>>>> self-reference error for every simulating halt decider: >>>>>> An input is decided to be halting only if its simulation never needs >>>>>> to be stopped by any simulating halt decider anywhere in its entire >>>>>> invocation chain." >>>>>> The result is that you are no longer talking the halting problem. It's >>>>>> a new problem: the Peter Olcott Other Halting problem where a decider >>>>>> that rejects some halting computation is "correct". >>>>>> "On that basis" (you go on to say): >>>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>>> clearly showing H rejecting a halting computation. You are admirably >>>>>> clear. To avoid the problem present in the proof, you redefine halting >>>>>> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >>>>>> >>>>>>>>> All of the "rebuttals" have taken the form of the strawman error: >>>>>>>>> The halting theorem does not specify a simulating halt decider. >>>>>>>>> This is no actual rebuttal to the original claim at all. >>>>>>>> >>>>>>>> No, the rebuttals start with a simple fact: false is not the correct >>>>>>>> answer for a halting computation. The rest of the rebuttal comes from >>>>>>>> you (it has to since you are carefully hiding the code): >>>>>> You cut the part where I quote you acknowledging that >>>>>> Halts(Confound_Halts, Confound_Halts) returns false despite >>>>>> Confound_Halts(Confound_Halts) being a finite computation. >>>>>> But no matter, it was there about TMs in 2017: >>>>>> On that basis >>>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>>> "That basis" being "the other kind of halting that does not mean >>>>>> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). >>>> It's extraordinary that you complain that no one ever points out errors, >>>> or that there arguments are all straw men, but when it's clearly pointed >>>> out to you, using your own posts, you have nothing to say! Not a word. >> Not a word about having switched from talking about the halting problem >> to talking about your POOH problem. Re-defining the term "halting" so >> the wrong answer: >> H(<Ĥ>,<Ĥ>) ⊢* H.qn >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> is called "correct". You have been clear about this time and time >> again. Your code sketch of Halts was correct because of what would >> happen if line 15 were commented out. False is the correct answer for >> some halting computations because they only halt for a reason you >> consider special. >> This switch in the problem is not hidden. You are explicit about it. >> The deception all comes about in trying to pretend that is this what >> Linz was talking about. No. Linz was talking about actual halting: >> H(<Ĥ>,<Ĥ>) ⊢* H.qn iff and only if Ĥ(<Ĥ>) ⊢* oo. >> That's why you must keep lying about Linz's Ĥ like this: >> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >> You must remove Linz's correct annotations and replace them with your >> junk ones to try to hint that you are talking about an Ĥ like Linz's. >> >>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. >>> The halt decider does not decide that halt status of itself. >>> The halt decider decides the halt status of its input. >>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. >>> >>> Since you already know these things are true denying them is >>> dishonest. >> It's possible you are so confused that you think these things explain >> why you've removed Linz's correct description of the behaviour of Ĥ. >> But, one way or another, you are being deceptive and I can't do anything >> but call you out on it. I'm happy to help if you genuinely don't follow >> what Linz concludes about the behaviour of Ĥ, but your track record in >> understand these things is very poor. >> >>> Some people are confused and believe that they are pointing out errors >>> and some people use the dishonest dodge tactic of the strawman error >>> to fool others into believing that they pointed out errors. >> That's for others to judge. I quote you explicitly replacing halting >> with your own silly criterion and then stating, clear as day, that H is >> correct to reject at least one halting computation: >> "On that basis >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> H(<Ĥ>,<Ĥ>) ⊢* H.qn" >> I am confident that no intelligent reader will call this a strawman. >> It's the simplest possible summary of why you are not addressing the >> theorem you are so obsessed about. >> But since you are just making up your own "Peter Olcott Other Halting" >> problem, it's not really an error. It's not even an error to replace >> Linz's correct annotations about the behaviour of Ĥ with your own >> because, technically, you are no longer talking about Linz H/Ĥ pair >> anymore. It's more about deception and dishonesty than it about >> errors. If you didn't try to pretend that your POOH problem is just the >> same as the halting problem, we could all simply ignore your posts since >> no one cares about POOH. > > This seems to be over your head: > H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ You should probably start by addressing why you think you get to redefine halting, and why anyone would care about the resulting decision problem. A POOH decider that "correctly" rejects a halting computation is simply junk. No one cares about your POOH problem: 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. On that basis: Ĥ(<Ĥ>) ⊢* Ĥ.qn H(<Ĥ>,<Ĥ>) ⊢* H.qn -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-29 18:22 -0500 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <Rb2dnWvRXfq5aMn8nZ2dnUU7-R3NnZ2d@giganews.com> |
| In reply to | #40081 |
On 9/29/2021 5:17 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/28/2021 8:14 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 9/28/2021 10:14 AM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>> >>>>>>>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>> >>>>>>>>>> This is the key basis of my refutation of the halting theorem: >>>>>>>>> >>>>>>>>> You would have to find a logical flaw in the proofs. All of them. But >>>>>>>>> you have not even read the "proper" proof in Linz. The one that you can >>>>>>>>> understand is only presented for historical reasons. >>>>>>>> >>>>>>>> The logical flaw is that the halting theorem attempts to show that the >>>>>>>> halting problem is undecidable by a counter-example that is clearly >>>>>>>> decidable as non-halting. >>>>>>> But first you changed the definition of halting: >>>>>>> "This definition of halting circumvents the pathological >>>>>>> self-reference error for every simulating halt decider: >>>>>>> An input is decided to be halting only if its simulation never needs >>>>>>> to be stopped by any simulating halt decider anywhere in its entire >>>>>>> invocation chain." >>>>>>> The result is that you are no longer talking the halting problem. It's >>>>>>> a new problem: the Peter Olcott Other Halting problem where a decider >>>>>>> that rejects some halting computation is "correct". >>>>>>> "On that basis" (you go on to say): >>>>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>>>> clearly showing H rejecting a halting computation. You are admirably >>>>>>> clear. To avoid the problem present in the proof, you redefine halting >>>>>>> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >>>>>>> >>>>>>>>>> All of the "rebuttals" have taken the form of the strawman error: >>>>>>>>>> The halting theorem does not specify a simulating halt decider. >>>>>>>>>> This is no actual rebuttal to the original claim at all. >>>>>>>>> >>>>>>>>> No, the rebuttals start with a simple fact: false is not the correct >>>>>>>>> answer for a halting computation. The rest of the rebuttal comes from >>>>>>>>> you (it has to since you are carefully hiding the code): >>>>>>> You cut the part where I quote you acknowledging that >>>>>>> Halts(Confound_Halts, Confound_Halts) returns false despite >>>>>>> Confound_Halts(Confound_Halts) being a finite computation. >>>>>>> But no matter, it was there about TMs in 2017: >>>>>>> On that basis >>>>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>>>> "That basis" being "the other kind of halting that does not mean >>>>>>> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). >>>>> It's extraordinary that you complain that no one ever points out errors, >>>>> or that there arguments are all straw men, but when it's clearly pointed >>>>> out to you, using your own posts, you have nothing to say! Not a word. >>> Not a word about having switched from talking about the halting problem >>> to talking about your POOH problem. Re-defining the term "halting" so >>> the wrong answer: >>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>> is called "correct". You have been clear about this time and time >>> again. Your code sketch of Halts was correct because of what would >>> happen if line 15 were commented out. False is the correct answer for >>> some halting computations because they only halt for a reason you >>> consider special. >>> This switch in the problem is not hidden. You are explicit about it. >>> The deception all comes about in trying to pretend that is this what >>> Linz was talking about. No. Linz was talking about actual halting: >>> H(<Ĥ>,<Ĥ>) ⊢* H.qn iff and only if Ĥ(<Ĥ>) ⊢* oo. >>> That's why you must keep lying about Linz's Ĥ like this: >>> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>>> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >>> You must remove Linz's correct annotations and replace them with your >>> junk ones to try to hint that you are talking about an Ĥ like Linz's. >>> >>>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. >>>> The halt decider does not decide that halt status of itself. >>>> The halt decider decides the halt status of its input. >>>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. >>>> >>>> Since you already know these things are true denying them is >>>> dishonest. >>> It's possible you are so confused that you think these things explain >>> why you've removed Linz's correct description of the behaviour of Ĥ. >>> But, one way or another, you are being deceptive and I can't do anything >>> but call you out on it. I'm happy to help if you genuinely don't follow >>> what Linz concludes about the behaviour of Ĥ, but your track record in >>> understand these things is very poor. >>> >>>> Some people are confused and believe that they are pointing out errors >>>> and some people use the dishonest dodge tactic of the strawman error >>>> to fool others into believing that they pointed out errors. >>> That's for others to judge. I quote you explicitly replacing halting >>> with your own silly criterion and then stating, clear as day, that H is >>> correct to reject at least one halting computation: >>> "On that basis >>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>> H(<Ĥ>,<Ĥ>) ⊢* H.qn" >>> I am confident that no intelligent reader will call this a strawman. >>> It's the simplest possible summary of why you are not addressing the >>> theorem you are so obsessed about. >>> But since you are just making up your own "Peter Olcott Other Halting" >>> problem, it's not really an error. It's not even an error to replace >>> Linz's correct annotations about the behaviour of Ĥ with your own >>> because, technically, you are no longer talking about Linz H/Ĥ pair >>> anymore. It's more about deception and dishonesty than it about >>> errors. If you didn't try to pretend that your POOH problem is just the >>> same as the halting problem, we could all simply ignore your posts since >>> no one cares about POOH. >> >> This seems to be over your head: >> H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ > > You should probably start by addressing why you think you get to > redefine halting, and why anyone would care about the resulting decision > problem. A POOH decider that "correctly" rejects a halting computation > is simply junk. No one cares about your POOH problem: > > 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. > This can be rephrased in conventional terms as the simulation of the input (P,P) to simulating halt decider H never reaches it final state whether or not H aborts the simulation of this input. > On that basis: > Ĥ(<Ĥ>) ⊢* Ĥ.qn > H(<Ĥ>,<Ĥ>) ⊢* H.qn > -- 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-29 20:23 -0400 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <4s75J.85951$Dr.70446@fx40.iad> |
| In reply to | #40087 |
On 9/29/21 7:22 PM, olcott wrote: > On 9/29/2021 5:17 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/28/2021 8:14 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 9/28/2021 10:14 AM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> 9/27/2021 8:45 PM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>> >>>>>>>>> On 9/27/2021 2:52 PM, Ben Bacarisse wrote: >>>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>> >>>>>>>>>>> This is the key basis of my refutation of the halting theorem: >>>>>>>>>> >>>>>>>>>> You would have to find a logical flaw in the proofs. All of >>>>>>>>>> them. But >>>>>>>>>> you have not even read the "proper" proof in Linz. The one >>>>>>>>>> that you can >>>>>>>>>> understand is only presented for historical reasons. >>>>>>>>> >>>>>>>>> The logical flaw is that the halting theorem attempts to show >>>>>>>>> that the >>>>>>>>> halting problem is undecidable by a counter-example that is >>>>>>>>> clearly >>>>>>>>> decidable as non-halting. >>>>>>>> But first you changed the definition of halting: >>>>>>>> "This definition of halting circumvents the pathological >>>>>>>> self-reference error for every simulating halt decider: >>>>>>>> An input is decided to be halting only if its simulation >>>>>>>> never needs >>>>>>>> to be stopped by any simulating halt decider anywhere in >>>>>>>> its entire >>>>>>>> invocation chain." >>>>>>>> The result is that you are no longer talking the halting >>>>>>>> problem. It's >>>>>>>> a new problem: the Peter Olcott Other Halting problem where a >>>>>>>> decider >>>>>>>> that rejects some halting computation is "correct". >>>>>>>> "On that basis" (you go on to say): >>>>>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>>>>> clearly showing H rejecting a halting computation. You are >>>>>>>> admirably >>>>>>>> clear. To avoid the problem present in the proof, you redefine >>>>>>>> halting >>>>>>>> so that H rejecting <Ĥ>,<Ĥ> is declared to be correct. >>>>>>>> >>>>>>>>>>> All of the "rebuttals" have taken the form of the strawman >>>>>>>>>>> error: >>>>>>>>>>> The halting theorem does not specify a simulating halt decider. >>>>>>>>>>> This is no actual rebuttal to the original claim at all. >>>>>>>>>> >>>>>>>>>> No, the rebuttals start with a simple fact: false is not the >>>>>>>>>> correct >>>>>>>>>> answer for a halting computation. The rest of the rebuttal >>>>>>>>>> comes from >>>>>>>>>> you (it has to since you are carefully hiding the code): >>>>>>>> You cut the part where I quote you acknowledging that >>>>>>>> Halts(Confound_Halts, Confound_Halts) returns false despite >>>>>>>> Confound_Halts(Confound_Halts) being a finite computation. >>>>>>>> But no matter, it was there about TMs in 2017: >>>>>>>> On that basis >>>>>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>>>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>>>>>> "That basis" being "the other kind of halting that does not mean >>>>>>>> halting": Ĥ(<Ĥ>) halts (in state Ĥ.qn) but H rejects (<Ĥ>,<Ĥ>). >>>>>> It's extraordinary that you complain that no one ever points out >>>>>> errors, >>>>>> or that there arguments are all straw men, but when it's clearly >>>>>> pointed >>>>>> out to you, using your own posts, you have nothing to say! Not a >>>>>> word. >>>> Not a word about having switched from talking about the halting problem >>>> to talking about your POOH problem. Re-defining the term "halting" so >>>> the wrong answer: >>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>> is called "correct". You have been clear about this time and time >>>> again. Your code sketch of Halts was correct because of what would >>>> happen if line 15 were commented out. False is the correct answer for >>>> some halting computations because they only halt for a reason you >>>> consider special. >>>> This switch in the problem is not hidden. You are explicit about it. >>>> The deception all comes about in trying to pretend that is this what >>>> Linz was talking about. No. Linz was talking about actual halting: >>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn iff and only if Ĥ(<Ĥ>) ⊢* oo. >>>> That's why you must keep lying about Linz's Ĥ like this: >>>> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and >>>>> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt >>>> You must remove Linz's correct annotations and replace them with your >>>> junk ones to try to hint that you are talking about an Ĥ like Linz's. >>>> >>>>> The halt decider is at Ĥ.qx. The halt decider is not at Ĥ.q0. >>>>> The halt decider does not decide that halt status of itself. >>>>> The halt decider decides the halt status of its input. >>>>> The input to the halt decider at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>> >>>>> Since you already know these things are true denying them is >>>>> dishonest. >>>> It's possible you are so confused that you think these things explain >>>> why you've removed Linz's correct description of the behaviour of Ĥ. >>>> But, one way or another, you are being deceptive and I can't do >>>> anything >>>> but call you out on it. I'm happy to help if you genuinely don't >>>> follow >>>> what Linz concludes about the behaviour of Ĥ, but your track record in >>>> understand these things is very poor. >>>> >>>>> Some people are confused and believe that they are pointing out errors >>>>> and some people use the dishonest dodge tactic of the strawman error >>>>> to fool others into believing that they pointed out errors. >>>> That's for others to judge. I quote you explicitly replacing halting >>>> with your own silly criterion and then stating, clear as day, that H is >>>> correct to reject at least one halting computation: >>>> "On that basis >>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn" >>>> I am confident that no intelligent reader will call this a strawman. >>>> It's the simplest possible summary of why you are not addressing the >>>> theorem you are so obsessed about. >>>> But since you are just making up your own "Peter Olcott Other Halting" >>>> problem, it's not really an error. It's not even an error to replace >>>> Linz's correct annotations about the behaviour of Ĥ with your own >>>> because, technically, you are no longer talking about Linz H/Ĥ pair >>>> anymore. It's more about deception and dishonesty than it about >>>> errors. If you didn't try to pretend that your POOH problem is just >>>> the >>>> same as the halting problem, we could all simply ignore your posts >>>> since >>>> no one cares about POOH. >>> >>> This seems to be over your head: >>> H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ >> >> You should probably start by addressing why you think you get to >> redefine halting, and why anyone would care about the resulting decision >> problem. A POOH decider that "correctly" rejects a halting computation >> is simply junk. No one cares about your POOH problem: >> >> 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. >> > > This can be rephrased in conventional terms as the simulation of the > input (P,P) to simulating halt decider H never reaches it final state > whether or not H aborts the simulation of this input. Who cares a F**king S**t that H doesn't see its simulation of P(P) Halt. Even you admit, that when we run P(P) as an independent machine it halts. THAT is what the Halting Question is asking about. Nobody (except maybe you) cares about what a defective decider does in its simulation. THat is just POOP. > >> On that basis: >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> H(<Ĥ>,<Ĥ>) ⊢* H.qn >> > >
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-30 02:31 +0100 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <878rzeonlm.fsf@bsb.me.uk> |
| In reply to | #40087 |
olcott <NoOne@NoWhere.com> writes: > On 9/29/2021 5:17 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >>> This seems to be over your head: >>> H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ >> >> You should probably start by addressing why you think you get to >> redefine halting, and why anyone would care about the resulting decision >> problem. A POOH decider that "correctly" rejects a halting computation >> is simply junk. No one cares about your POOH problem: >> >> 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. > > This can be rephrased in conventional terms as the simulation of the > input (P,P) to simulating halt decider H never reaches it final state > whether or not H aborts the simulation of this input. You can rephrase it in Catalan if you like. The definition, however you rephrase it, permits: >> On that basis: >> Ĥ(<Ĥ>) ⊢* Ĥ.qn >> H(<Ĥ>,<Ĥ>) ⊢* H.qn so your Ĥ is not Linz's Ĥ and no one cares about what it, and the H it comes from, does. TMs that reject halting computations are ten-a-penny. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-29 20:37 -0500 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <TYudncbcf9x5icj8nZ2dnUU7-LnNnZ2d@giganews.com> |
| In reply to | #40093 |
On 9/29/2021 8:31 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 9/29/2021 5:17 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: > >>>> This seems to be over your head: >>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ >>> >>> You should probably start by addressing why you think you get to >>> redefine halting, and why anyone would care about the resulting decision >>> problem. A POOH decider that "correctly" rejects a halting computation >>> is simply junk. No one cares about your POOH problem: >>> >>> 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. >> >> This can be rephrased in conventional terms as the simulation of the >> input (P,P) to simulating halt decider H never reaches it final state >> whether or not H aborts the simulation of this input. > > You can rephrase it in Catalan if you like. The definition, however you > rephrase it, permits: > >>> On that basis: >>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>> H(<Ĥ>,<Ĥ>) ⊢* H.qn > > so your Ĥ is not Linz's Ĥ and no one cares about what it, and the H it > comes from, does. TMs that reject halting computations are ten-a-penny. > 1----2-----3-----4--5-----6 Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn No it does not because the simulating halt decider is at (3) and simulating (4) on input (5). The question about (1) on (2) is not what Linz is referring to. H(<Ĥ>,<Ĥ>) ⊢* H.qy is what my H1(P,P) proves. -- 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-30 02:51 +0100 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <87r1d6n844.fsf@bsb.me.uk> |
| In reply to | #40096 |
olcott <NoOne@NoWhere.com> writes:
> On 9/29/2021 8:31 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 9/29/2021 5:17 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>> This seems to be over your head:
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>
>>>> You should probably start by addressing why you think you get to
>>>> redefine halting, and why anyone would care about the resulting decision
>>>> problem. A POOH decider that "correctly" rejects a halting computation
>>>> is simply junk. No one cares about your POOH problem:
>>>>
>>>> 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.
>>>
>>> This can be rephrased in conventional terms as the simulation of the
>>> input (P,P) to simulating halt decider H never reaches it final state
>>> whether or not H aborts the simulation of this input.
>>
>> You can rephrase it in Catalan if you like. The definition, however you
>> rephrase it, permits:
>>
>>>> On that basis:
>>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn
>>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn
>>
>> so your Ĥ is not Linz's Ĥ and no one cares about what it, and the H it
>> comes from, does. TMs that reject halting computations are ten-a-penny.
>
> 1----2-----3-----4--5-----6
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> No it does not
Don't lie. Your words are right there: on the basis of your new
definition of "halting":
Ĥ(<Ĥ>) ⊢* Ĥ.qn
H(<Ĥ>,<Ĥ>) ⊢* H.qn
That's H rejecting a halting computation. That's a statement about a TM
pair H/Ĥ that is entirely unlike Linz's H/Ĥ pair.
> The question about (1) on (2) is not what Linz is referring to.
It is when he says "if applied to ⟨Ĥ⟩ halts". He is referring precisely
to (1) on (2).
> H(<Ĥ>,<Ĥ>) ⊢* H.qy is what my H1(P,P) proves.
Which is it: H(<Ĥ>,<Ĥ>) ⊢* H.qy or H(<Ĥ>,<Ĥ>) ⊢* H.qn? There's a
question you'll probably dodge for the next three weeks!
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-29 21:53 -0400 |
| Subject | Re: When an input TM description can never reach its final state it is non halting |
| Message-ID | <XM85J.7327$fZ.2102@fx06.iad> |
| In reply to | #40096 |
On 9/29/21 9:37 PM, olcott wrote: > On 9/29/2021 8:31 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 9/29/2021 5:17 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >> >>>>> This seems to be over your head: >>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ is an entirely different computation than Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ >>>> >>>> You should probably start by addressing why you think you get to >>>> redefine halting, and why anyone would care about the resulting >>>> decision >>>> problem. A POOH decider that "correctly" rejects a halting computation >>>> is simply junk. No one cares about your POOH problem: >>>> >>>> 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. >>> >>> This can be rephrased in conventional terms as the simulation of the >>> input (P,P) to simulating halt decider H never reaches it final state >>> whether or not H aborts the simulation of this input. >> >> You can rephrase it in Catalan if you like. The definition, however you >> rephrase it, permits: >> >>>> On that basis: >>>> Ĥ(<Ĥ>) ⊢* Ĥ.qn >>>> H(<Ĥ>,<Ĥ>) ⊢* H.qn >> >> so your Ĥ is not Linz's Ĥ and no one cares about what it, and the H it >> comes from, does. TMs that reject halting computations are ten-a-penny. >> > > 1----2-----3-----4--5-----6 > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn > > No it does not because the simulating halt decider is at (3) and > simulating (4) on input (5). > > The question about (1) on (2) is not what Linz is referring to. > > H(<Ĥ>,<Ĥ>) ⊢* H.qy is what my H1(P,P) proves. > PO-H1 can't be the Linz-H as it gives a different answer to H^/P then the machine embedded into H^/P (thst or it isn't even a Comptation, and thus isn't qualified to be a decider). You FAIL reading comprehension.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 12:12 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <taqdnaslBqAMZsz8nZ2dnUU7-TWdnZ2d@giganews.com> |
| In reply to | #39967 |
On 9/27/2021 9: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:
>>>> On 2021-09-26 21:16, olcott wrote:
>>>>> On 9/26/2021 9:41 PM, André G. Isaak wrote:
>>>>>> On 2021-09-26 20:03, olcott wrote:
>>>>>>> On 9/26/2021 8:40 PM, André G. Isaak wrote:
>>>>>>>> On 2021-09-26 18:07, olcott wrote:
>>>>>>>>> On 9/26/2021 2:40 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/26/21 2:39 PM, olcott wrote:
>>>>>>>>>>> On 9/26/2021 1:34 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/26/21 2:28 PM, olcott wrote:
>>>>>>>>>>>>> On 9/21/2021 9:25 PM, olcott wrote:
>>>>>>>>>>>>>> void P(u8* program)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u8* input;
>>>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>>>> u32 Input_Halts = halt_decider(program, input);
>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u8* program = (u8*)Allocate(1024);
>>>>>>>>>>>>>> u8* input;
>>>>>>>>>>>>>> CopyMemory3((u8*)P, (u8*)program);
>>>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>>>> Output("Input_Halts = ", halt_decider(program, input));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> As with my other proofs the halt status is correctly decided.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This paper will be completely rewritten with my new
>>>>>>>>>>>>>> findings as soon
>>>>>>>>>>>>>> as they are fully operational. The key feasibility test
>>>>>>>>>>>>>> elements are
>>>>>>>>>>>>>> already fully operational. The architectural design is
>>>>>>>>>>>>>> complete.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To the best of my current knowledge the only steps
>>>>>>>>>>>>>> required to make
>>>>>>>>>>>>>> this system fully operational are relatively minor
>>>>>>>>>>>>>> ordinary C/x86
>>>>>>>>>>>>>> operating system level programming.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> This was my key 2016 Breakthrough:
>>>>>>>>>>>>> The halting theorem counter-examples present infinitely nested
>>>>>>>>>>>>> simulation (non-halting) behavior to every simulating halt
>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It looks like I will be able to reproduce my original
>>>>>>>>>>>>> results where the
>>>>>>>>>>>>> halt_decider is a pure function.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>>>>> arguments (no
>>>>>>>>>>>>> variation with local static variables, non-local variables,
>>>>>>>>>>>>> mutable
>>>>>>>>>>>>> reference arguments or input streams).
>>>>>>>>>>>>>
>>>>>>>>>>>>> (2) The function application has no side effects (no
>>>>>>>>>>>>> mutation of local
>>>>>>>>>>>>> static variables, non-local variables, mutable reference
>>>>>>>>>>>>> arguments or
>>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>>
>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *IF* that is true, then it is the equivalent of a Turing
>>>>>>>>>>>> Machine.
>>>>>>>>>>>>
>>>>>>>>>>>> The next question is can you make it produce the right answer.
>>>>>>>>>>>>
>>>>>>>>>>>> H(P,P) needs to say Halting if P(P) halts, and Non-halting
>>>>>>>>>>>> if P(P) will
>>>>>>>>>>>> never Halt.
>>>>>>>>>>>>
>>>>>>>>>>>> None of this false reasoning that just because the partial
>>>>>>>>>>>> simulation
>>>>>>>>>>>> that H has performed didn't reach a Halt State is some how
>>>>>>>>>>>> proof that
>>>>>>>>>>>> the actual machine won't halt if it was run a little bit
>>>>>>>>>>>> longer.
>>>>>>>>>>>>
>>>>>>>>>>>> The question of a Halt Decider is ALWAYS about the Machine
>>>>>>>>>>>> represented
>>>>>>>>>>>> by the input, and not about some partial simulation that the
>>>>>>>>>>>> decider has
>>>>>>>>>>>> done.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> This is the part where your understanding is abysmal. An
>>>>>>>>>>> infinite
>>>>>>>>>>> simulation of P(P) never reaches the final state of P at 0x187c.
>>>>>>>>>>>
>>>>>>>>>>> _P()
>>>>>>>>>>> [00001862](01) 55 push ebp
>>>>>>>>>>> [00001863](02) 8bec mov ebp,esp
>>>>>>>>>>> [00001865](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [00001868](01) 50 push eax
>>>>>>>>>>> [00001869](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [0000186c](01) 51 push ecx
>>>>>>>>>>> [0000186d](05) e810fdffff call 00001582
>>>>>>>>>>> [00001872](03) 83c408 add esp,+08
>>>>>>>>>>> [00001875](02) 85c0 test eax,eax
>>>>>>>>>>> [00001877](02) 7402 jz 0000187b
>>>>>>>>>>> [00001879](02) ebfe jmp 00001879
>>>>>>>>>>> [0000187b](01) 5d pop ebp
>>>>>>>>>>> [0000187c](01) c3 ret
>>>>>>>>>>> Size in bytes:(0027) [0000187c]
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It doesn't matter if the PARTIAL simulation of P by H never
>>>>>>>>>> gets there.
>>>>>>>>>> That just shows that H decided to give up too soon.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I don't see how you can construe infinite simulation as partial
>>>>>>>>> simulation without you having some sort of brain damage.
>>>>>>>>
>>>>>>>> If there were actually 'infinite simulation' going on then your
>>>>>>>> H(P, P) wouldn't be able to give an answer and thus would not be
>>>>>>>> a decider.
>>>>>>>>
>>>>>>>
>>>>>>> If H aborts its simulation of P(P) P never reaches its final
>>>>>>> state of 0x187c. P never gets past its state of 0x186d.
>>>>>>
>>>>>> If H aborts its simulation, then H does *not* involve infinite
>>>>>> recursive simulation, your claims to the contrary notwithstanding.
>>>>>>
>>>>>> When a simulated computation doesn't reach its final state because
>>>>>> it is aborted, that tells us nothing about whether the simulated
>>>>>> computation is halting.
>>>>>
>>>>>> Had the simulation been allowed to continue you would find that
>>>>>> the simulated P(P) would abort its input just as H(P, P) does,
>>>>>> meaning that P(P) is a halting computation.
>>>>>>
>>>>>>> If H If H NEVER aborts its simulation of P(P) P never reaches its
>>>>>>> final state of 0x187c. P never gets past its state of 0x186d.
>>>>>>
>>>>>> If H never aborts its simulation, then you are talking about a
>>>>>> *different* program from your H. What happens in that other
>>>>>> program has no relevance to your H.
>>>>>>
>>>>>
>>>>> Whether or not H aborts its simulation of P(P), the input to H(P,P)
>>>>> never reaches its final state therefore we can know that the input
>>>>> to H(P,P) is definitely not a halting computation.
>>>>
>>>> This claim is simply false. If H(P, P) didn't abort its simulation,
>>>> the simulation *would* reach its final state. That's why P(P), when
>>>> run independently, halts.
>>>>
>>>> André
>>>>
>>>
>>> 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.
>
When I say that you are a clueless wonder I am only referring to your
rebuttals of my work. It is clear that you do have good understanding of
some key aspects of software engineering.
--
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 06:43 -0400 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <pfh4J.206216$T_8.62670@fx48.iad> |
| In reply to | #39962 |
On 9/27/21 12:31 AM, olcott wrote:
> On 9/26/2021 10:56 PM, André G. Isaak wrote:
>> On 2021-09-26 21:16, olcott wrote:
>>> On 9/26/2021 9:41 PM, André G. Isaak wrote:
>>>> On 2021-09-26 20:03, olcott wrote:
>>>>> On 9/26/2021 8:40 PM, André G. Isaak wrote:
>>>>>> On 2021-09-26 18:07, olcott wrote:
>>>>>>> On 9/26/2021 2:40 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/26/21 2:39 PM, olcott wrote:
>>>>>>>>> On 9/26/2021 1:34 PM, Richard Damon wrote:
>>>>>>>>>> On 9/26/21 2:28 PM, olcott wrote:
>>>>>>>>>>> On 9/21/2021 9:25 PM, olcott wrote:
>>>>>>>>>>>> void P(u8* program)
>>>>>>>>>>>> {
>>>>>>>>>>>> u8* input;
>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>> u32 Input_Halts = halt_decider(program, input);
>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> u8* program = (u8*)Allocate(1024);
>>>>>>>>>>>> u8* input;
>>>>>>>>>>>> CopyMemory3((u8*)P, (u8*)program);
>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>> Output("Input_Halts = ", halt_decider(program, input));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> As with my other proofs the halt status is correctly decided.
>>>>>>>>>>>>
>>>>>>>>>>>> This paper will be completely rewritten with my new findings
>>>>>>>>>>>> as soon
>>>>>>>>>>>> as they are fully operational. The key feasibility test
>>>>>>>>>>>> elements are
>>>>>>>>>>>> already fully operational. The architectural design is
>>>>>>>>>>>> complete.
>>>>>>>>>>>>
>>>>>>>>>>>> To the best of my current knowledge the only steps required
>>>>>>>>>>>> to make
>>>>>>>>>>>> this system fully operational are relatively minor ordinary
>>>>>>>>>>>> C/x86
>>>>>>>>>>>> operating system level programming.
>>>>>>>>>>>>
>>>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> This was my key 2016 Breakthrough:
>>>>>>>>>>> The halting theorem counter-examples present infinitely nested
>>>>>>>>>>> simulation (non-halting) behavior to every simulating halt
>>>>>>>>>>> decider.
>>>>>>>>>>>
>>>>>>>>>>> It looks like I will be able to reproduce my original results
>>>>>>>>>>> where the
>>>>>>>>>>> halt_decider is a pure function.
>>>>>>>>>>>
>>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>>> arguments (no
>>>>>>>>>>> variation with local static variables, non-local variables,
>>>>>>>>>>> mutable
>>>>>>>>>>> reference arguments or input streams).
>>>>>>>>>>>
>>>>>>>>>>> (2) The function application has no side effects (no mutation
>>>>>>>>>>> of local
>>>>>>>>>>> static variables, non-local variables, mutable reference
>>>>>>>>>>> arguments or
>>>>>>>>>>> input/output streams).
>>>>>>>>>>>
>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *IF* that is true, then it is the equivalent of a Turing Machine.
>>>>>>>>>>
>>>>>>>>>> The next question is can you make it produce the right answer.
>>>>>>>>>>
>>>>>>>>>> H(P,P) needs to say Halting if P(P) halts, and Non-halting if
>>>>>>>>>> P(P) will
>>>>>>>>>> never Halt.
>>>>>>>>>>
>>>>>>>>>> None of this false reasoning that just because the partial
>>>>>>>>>> simulation
>>>>>>>>>> that H has performed didn't reach a Halt State is some how
>>>>>>>>>> proof that
>>>>>>>>>> the actual machine won't halt if it was run a little bit longer.
>>>>>>>>>>
>>>>>>>>>> The question of a Halt Decider is ALWAYS about the Machine
>>>>>>>>>> represented
>>>>>>>>>> by the input, and not about some partial simulation that the
>>>>>>>>>> decider has
>>>>>>>>>> done.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> This is the part where your understanding is abysmal. An infinite
>>>>>>>>> simulation of P(P) never reaches the final state of P at 0x187c.
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [00001862](01) 55 push ebp
>>>>>>>>> [00001863](02) 8bec mov ebp,esp
>>>>>>>>> [00001865](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00001868](01) 50 push eax
>>>>>>>>> [00001869](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [0000186c](01) 51 push ecx
>>>>>>>>> [0000186d](05) e810fdffff call 00001582
>>>>>>>>> [00001872](03) 83c408 add esp,+08
>>>>>>>>> [00001875](02) 85c0 test eax,eax
>>>>>>>>> [00001877](02) 7402 jz 0000187b
>>>>>>>>> [00001879](02) ebfe jmp 00001879
>>>>>>>>> [0000187b](01) 5d pop ebp
>>>>>>>>> [0000187c](01) c3 ret
>>>>>>>>> Size in bytes:(0027) [0000187c]
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> It doesn't matter if the PARTIAL simulation of P by H never gets
>>>>>>>> there.
>>>>>>>> That just shows that H decided to give up too soon.
>>>>>>>>
>>>>>>>
>>>>>>> I don't see how you can construe infinite simulation as partial
>>>>>>> simulation without you having some sort of brain damage.
>>>>>>
>>>>>> If there were actually 'infinite simulation' going on then your
>>>>>> H(P, P) wouldn't be able to give an answer and thus would not be a
>>>>>> decider.
>>>>>>
>>>>>
>>>>> If H aborts its simulation of P(P) P never reaches its final state
>>>>> of 0x187c. P never gets past its state of 0x186d.
>>>>
>>>> If H aborts its simulation, then H does *not* involve infinite
>>>> recursive simulation, your claims to the contrary notwithstanding.
>>>>
>>>> When a simulated computation doesn't reach its final state because
>>>> it is aborted, that tells us nothing about whether the simulated
>>>> computation is halting.
>>>
>>>> Had the simulation been allowed to continue you would find that the
>>>> simulated P(P) would abort its input just as H(P, P) does, meaning
>>>> that P(P) is a halting computation.
>>>>
>>>>> If H If H NEVER aborts its simulation of P(P) P never reaches its
>>>>> final state of 0x187c. P never gets past its state of 0x186d.
>>>>
>>>> If H never aborts its simulation, then you are talking about a
>>>> *different* program from your H. What happens in that other program
>>>> has no relevance to your H.
>>>>
>>>
>>> Whether or not H aborts its simulation of P(P), the input to H(P,P)
>>> never reaches its final state therefore we can know that the input to
>>> H(P,P) is definitely not a halting computation.
>>
>> This claim is simply false. If H(P, P) didn't abort its simulation,
>> the simulation *would* reach its final state. That's why P(P), when
>> run independently, halts.
>>
>> André
>>
>
> 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.
>
> _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)
>
>
>
And it can only do it for an infinite number of times for a DIFFERENT H.
Change you H, and you totally 'reset' the problem.
For the H that does lead to an infinite number of cycles, that H(P,P)
never answers, so it fails to be a decider, so it doesn't matter that
ITS P(P) in non-halting.
If that it the H you claim to have, that is the problem with it.
For the actual H you are normally claiming, it doesn't matter that some
other H shows an infinite number of cycles, for THIS H, it WILL abort
the simulation, and thus that H will only see 2 cycles and then abort,
which means that for any copy of P that we look at, it will only go 3
cycles, then the H it is using has seen its 2 cycles and then it will
abort and thus the P will Halt.
Three is not infinite, though it may be a big enough number that it
forces you into 'higher mathematics', needing to actually use your
fingers to count, instead of just clenched fists.
You keep on trying to confuse these case. As any point in your argument,
H can only represent a single decider with a specific behavior.
That is even a basic software principle, you can't have two routines
globally available with the same exact name available in a given program.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 09:32 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <pPKdncjFSuJ-SMz8nZ2dnUU7-bXNnZ2d@giganews.com> |
| In reply to | #39966 |
On 9/27/2021 5:43 AM, Richard Damon wrote:
> On 9/27/21 12:31 AM, olcott wrote:
>> On 9/26/2021 10:56 PM, André G. Isaak wrote:
>>> On 2021-09-26 21:16, olcott wrote:
>>>> On 9/26/2021 9:41 PM, André G. Isaak wrote:
>>>>> On 2021-09-26 20:03, olcott wrote:
>>>>>> On 9/26/2021 8:40 PM, André G. Isaak wrote:
>>>>>>> On 2021-09-26 18:07, olcott wrote:
>>>>>>>> On 9/26/2021 2:40 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/26/21 2:39 PM, olcott wrote:
>>>>>>>>>> On 9/26/2021 1:34 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/26/21 2:28 PM, olcott wrote:
>>>>>>>>>>>> On 9/21/2021 9:25 PM, olcott wrote:
>>>>>>>>>>>>> void P(u8* program)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> u8* input;
>>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>>> u32 Input_Halts = halt_decider(program, input);
>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> u8* program = (u8*)Allocate(1024);
>>>>>>>>>>>>> u8* input;
>>>>>>>>>>>>> CopyMemory3((u8*)P, (u8*)program);
>>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>>> Output("Input_Halts = ", halt_decider(program, input));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> As with my other proofs the halt status is correctly decided.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This paper will be completely rewritten with my new findings
>>>>>>>>>>>>> as soon
>>>>>>>>>>>>> as they are fully operational. The key feasibility test
>>>>>>>>>>>>> elements are
>>>>>>>>>>>>> already fully operational. The architectural design is
>>>>>>>>>>>>> complete.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To the best of my current knowledge the only steps required
>>>>>>>>>>>>> to make
>>>>>>>>>>>>> this system fully operational are relatively minor ordinary
>>>>>>>>>>>>> C/x86
>>>>>>>>>>>>> operating system level programming.
>>>>>>>>>>>>>
>>>>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> This was my key 2016 Breakthrough:
>>>>>>>>>>>> The halting theorem counter-examples present infinitely nested
>>>>>>>>>>>> simulation (non-halting) behavior to every simulating halt
>>>>>>>>>>>> decider.
>>>>>>>>>>>>
>>>>>>>>>>>> It looks like I will be able to reproduce my original results
>>>>>>>>>>>> where the
>>>>>>>>>>>> halt_decider is a pure function.
>>>>>>>>>>>>
>>>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>>>> arguments (no
>>>>>>>>>>>> variation with local static variables, non-local variables,
>>>>>>>>>>>> mutable
>>>>>>>>>>>> reference arguments or input streams).
>>>>>>>>>>>>
>>>>>>>>>>>> (2) The function application has no side effects (no mutation
>>>>>>>>>>>> of local
>>>>>>>>>>>> static variables, non-local variables, mutable reference
>>>>>>>>>>>> arguments or
>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *IF* that is true, then it is the equivalent of a Turing Machine.
>>>>>>>>>>>
>>>>>>>>>>> The next question is can you make it produce the right answer.
>>>>>>>>>>>
>>>>>>>>>>> H(P,P) needs to say Halting if P(P) halts, and Non-halting if
>>>>>>>>>>> P(P) will
>>>>>>>>>>> never Halt.
>>>>>>>>>>>
>>>>>>>>>>> None of this false reasoning that just because the partial
>>>>>>>>>>> simulation
>>>>>>>>>>> that H has performed didn't reach a Halt State is some how
>>>>>>>>>>> proof that
>>>>>>>>>>> the actual machine won't halt if it was run a little bit longer.
>>>>>>>>>>>
>>>>>>>>>>> The question of a Halt Decider is ALWAYS about the Machine
>>>>>>>>>>> represented
>>>>>>>>>>> by the input, and not about some partial simulation that the
>>>>>>>>>>> decider has
>>>>>>>>>>> done.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> This is the part where your understanding is abysmal. An infinite
>>>>>>>>>> simulation of P(P) never reaches the final state of P at 0x187c.
>>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [00001862](01) 55 push ebp
>>>>>>>>>> [00001863](02) 8bec mov ebp,esp
>>>>>>>>>> [00001865](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00001868](01) 50 push eax
>>>>>>>>>> [00001869](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [0000186c](01) 51 push ecx
>>>>>>>>>> [0000186d](05) e810fdffff call 00001582
>>>>>>>>>> [00001872](03) 83c408 add esp,+08
>>>>>>>>>> [00001875](02) 85c0 test eax,eax
>>>>>>>>>> [00001877](02) 7402 jz 0000187b
>>>>>>>>>> [00001879](02) ebfe jmp 00001879
>>>>>>>>>> [0000187b](01) 5d pop ebp
>>>>>>>>>> [0000187c](01) c3 ret
>>>>>>>>>> Size in bytes:(0027) [0000187c]
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It doesn't matter if the PARTIAL simulation of P by H never gets
>>>>>>>>> there.
>>>>>>>>> That just shows that H decided to give up too soon.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I don't see how you can construe infinite simulation as partial
>>>>>>>> simulation without you having some sort of brain damage.
>>>>>>>
>>>>>>> If there were actually 'infinite simulation' going on then your
>>>>>>> H(P, P) wouldn't be able to give an answer and thus would not be a
>>>>>>> decider.
>>>>>>>
>>>>>>
>>>>>> If H aborts its simulation of P(P) P never reaches its final state
>>>>>> of 0x187c. P never gets past its state of 0x186d.
>>>>>
>>>>> If H aborts its simulation, then H does *not* involve infinite
>>>>> recursive simulation, your claims to the contrary notwithstanding.
>>>>>
>>>>> When a simulated computation doesn't reach its final state because
>>>>> it is aborted, that tells us nothing about whether the simulated
>>>>> computation is halting.
>>>>
>>>>> Had the simulation been allowed to continue you would find that the
>>>>> simulated P(P) would abort its input just as H(P, P) does, meaning
>>>>> that P(P) is a halting computation.
>>>>>
>>>>>> If H If H NEVER aborts its simulation of P(P) P never reaches its
>>>>>> final state of 0x187c. P never gets past its state of 0x186d.
>>>>>
>>>>> If H never aborts its simulation, then you are talking about a
>>>>> *different* program from your H. What happens in that other program
>>>>> has no relevance to your H.
>>>>>
>>>>
>>>> Whether or not H aborts its simulation of P(P), the input to H(P,P)
>>>> never reaches its final state therefore we can know that the input to
>>>> H(P,P) is definitely not a halting computation.
>>>
>>> This claim is simply false. If H(P, P) didn't abort its simulation,
>>> the simulation *would* reach its final state. That's why P(P), when
>>> run independently, halts.
>>>
>>> André
>>>
>>
>> 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.
>>
>> _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)
>>
>>
>>
>
> And it can only do it for an infinite number of times for a DIFFERENT H.
>
> Change you H, and you totally 'reset' the problem.
>
Whether or not H aborts the simulation of its input the simulated input
to H(P,P) never reaches its final state. This conclusively proves that
the input to H(P,P) is not a halting computation.
Try to directly deny this or indirectly deny this by changing the
subject as a strawman error is dishonest.
--
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 20:09 -0400 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <63t4J.206938$T_8.39793@fx48.iad> |
| In reply to | #39970 |
On 9/27/21 10:32 AM, olcott wrote:
> On 9/27/2021 5:43 AM, Richard Damon wrote:
>> On 9/27/21 12:31 AM, olcott wrote:
>>> On 9/26/2021 10:56 PM, André G. Isaak wrote:
>>>> On 2021-09-26 21:16, olcott wrote:
>>>>> On 9/26/2021 9:41 PM, André G. Isaak wrote:
>>>>>> On 2021-09-26 20:03, olcott wrote:
>>>>>>> On 9/26/2021 8:40 PM, André G. Isaak wrote:
>>>>>>>> On 2021-09-26 18:07, olcott wrote:
>>>>>>>>> On 9/26/2021 2:40 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/26/21 2:39 PM, olcott wrote:
>>>>>>>>>>> On 9/26/2021 1:34 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/26/21 2:28 PM, olcott wrote:
>>>>>>>>>>>>> On 9/21/2021 9:25 PM, olcott wrote:
>>>>>>>>>>>>>> void P(u8* program)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u8* input;
>>>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>>>> u32 Input_Halts = halt_decider(program, input);
>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u8* program = (u8*)Allocate(1024);
>>>>>>>>>>>>>> u8* input;
>>>>>>>>>>>>>> CopyMemory3((u8*)P, (u8*)program);
>>>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>>>> Output("Input_Halts = ", halt_decider(program, input));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> As with my other proofs the halt status is correctly decided.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This paper will be completely rewritten with my new findings
>>>>>>>>>>>>>> as soon
>>>>>>>>>>>>>> as they are fully operational. The key feasibility test
>>>>>>>>>>>>>> elements are
>>>>>>>>>>>>>> already fully operational. The architectural design is
>>>>>>>>>>>>>> complete.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To the best of my current knowledge the only steps required
>>>>>>>>>>>>>> to make
>>>>>>>>>>>>>> this system fully operational are relatively minor ordinary
>>>>>>>>>>>>>> C/x86
>>>>>>>>>>>>>> operating system level programming.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> This was my key 2016 Breakthrough:
>>>>>>>>>>>>> The halting theorem counter-examples present infinitely nested
>>>>>>>>>>>>> simulation (non-halting) behavior to every simulating halt
>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It looks like I will be able to reproduce my original results
>>>>>>>>>>>>> where the
>>>>>>>>>>>>> halt_decider is a pure function.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>>>>> arguments (no
>>>>>>>>>>>>> variation with local static variables, non-local variables,
>>>>>>>>>>>>> mutable
>>>>>>>>>>>>> reference arguments or input streams).
>>>>>>>>>>>>>
>>>>>>>>>>>>> (2) The function application has no side effects (no mutation
>>>>>>>>>>>>> of local
>>>>>>>>>>>>> static variables, non-local variables, mutable reference
>>>>>>>>>>>>> arguments or
>>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>>
>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *IF* that is true, then it is the equivalent of a Turing
>>>>>>>>>>>> Machine.
>>>>>>>>>>>>
>>>>>>>>>>>> The next question is can you make it produce the right answer.
>>>>>>>>>>>>
>>>>>>>>>>>> H(P,P) needs to say Halting if P(P) halts, and Non-halting if
>>>>>>>>>>>> P(P) will
>>>>>>>>>>>> never Halt.
>>>>>>>>>>>>
>>>>>>>>>>>> None of this false reasoning that just because the partial
>>>>>>>>>>>> simulation
>>>>>>>>>>>> that H has performed didn't reach a Halt State is some how
>>>>>>>>>>>> proof that
>>>>>>>>>>>> the actual machine won't halt if it was run a little bit
>>>>>>>>>>>> longer.
>>>>>>>>>>>>
>>>>>>>>>>>> The question of a Halt Decider is ALWAYS about the Machine
>>>>>>>>>>>> represented
>>>>>>>>>>>> by the input, and not about some partial simulation that the
>>>>>>>>>>>> decider has
>>>>>>>>>>>> done.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> This is the part where your understanding is abysmal. An
>>>>>>>>>>> infinite
>>>>>>>>>>> simulation of P(P) never reaches the final state of P at 0x187c.
>>>>>>>>>>>
>>>>>>>>>>> _P()
>>>>>>>>>>> [00001862](01) 55 push ebp
>>>>>>>>>>> [00001863](02) 8bec mov ebp,esp
>>>>>>>>>>> [00001865](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [00001868](01) 50 push eax
>>>>>>>>>>> [00001869](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [0000186c](01) 51 push ecx
>>>>>>>>>>> [0000186d](05) e810fdffff call 00001582
>>>>>>>>>>> [00001872](03) 83c408 add esp,+08
>>>>>>>>>>> [00001875](02) 85c0 test eax,eax
>>>>>>>>>>> [00001877](02) 7402 jz 0000187b
>>>>>>>>>>> [00001879](02) ebfe jmp 00001879
>>>>>>>>>>> [0000187b](01) 5d pop ebp
>>>>>>>>>>> [0000187c](01) c3 ret
>>>>>>>>>>> Size in bytes:(0027) [0000187c]
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It doesn't matter if the PARTIAL simulation of P by H never gets
>>>>>>>>>> there.
>>>>>>>>>> That just shows that H decided to give up too soon.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I don't see how you can construe infinite simulation as partial
>>>>>>>>> simulation without you having some sort of brain damage.
>>>>>>>>
>>>>>>>> If there were actually 'infinite simulation' going on then your
>>>>>>>> H(P, P) wouldn't be able to give an answer and thus would not be a
>>>>>>>> decider.
>>>>>>>>
>>>>>>>
>>>>>>> If H aborts its simulation of P(P) P never reaches its final state
>>>>>>> of 0x187c. P never gets past its state of 0x186d.
>>>>>>
>>>>>> If H aborts its simulation, then H does *not* involve infinite
>>>>>> recursive simulation, your claims to the contrary notwithstanding.
>>>>>>
>>>>>> When a simulated computation doesn't reach its final state because
>>>>>> it is aborted, that tells us nothing about whether the simulated
>>>>>> computation is halting.
>>>>>
>>>>>> Had the simulation been allowed to continue you would find that the
>>>>>> simulated P(P) would abort its input just as H(P, P) does, meaning
>>>>>> that P(P) is a halting computation.
>>>>>>
>>>>>>> If H If H NEVER aborts its simulation of P(P) P never reaches its
>>>>>>> final state of 0x187c. P never gets past its state of 0x186d.
>>>>>>
>>>>>> If H never aborts its simulation, then you are talking about a
>>>>>> *different* program from your H. What happens in that other program
>>>>>> has no relevance to your H.
>>>>>>
>>>>>
>>>>> Whether or not H aborts its simulation of P(P), the input to H(P,P)
>>>>> never reaches its final state therefore we can know that the input to
>>>>> H(P,P) is definitely not a halting computation.
>>>>
>>>> This claim is simply false. If H(P, P) didn't abort its simulation,
>>>> the simulation *would* reach its final state. That's why P(P), when
>>>> run independently, halts.
>>>>
>>>> André
>>>>
>>>
>>> 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.
>>>
>>> _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)
>>>
>>>
>>>
>>
>> And it can only do it for an infinite number of times for a DIFFERENT H.
>>
>> Change you H, and you totally 'reset' the problem.
>>
>
> Whether or not H aborts the simulation of its input the simulated input
> to H(P,P) never reaches its final state. This conclusively proves that
> the input to H(P,P) is not a halting computation.
>
> Try to directly deny this or indirectly deny this by changing the
> subject as a strawman error is dishonest.
>
>
You keep on using that wrong problem. H is not being asked what its
partial simulation does, it is being aske what the actual computation
represented by the input. While it is true that H will not simulate H^/P
to its final Halting State, that doesn't mean that H^/P doesn't get there.
Do you actually think that you can keep your team from losing by turning
off the TV? That is basically the argument you are using, since H
doesn't see it, it didn't happen.
Yes, there IS an H that has this infinite loop, the H that never aborts
its simulation, but every H has its own H^/P to look at, so the fact
that the H^ built on the H that doesn't abort its simulation doesn't
Halt doesn't mean that the H^/P built on a H that does about its
simulation also doesn't hatt.
Thats like says since my pet dog barks, then my pet cat must bark also.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-27 06:33 -0400 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <k6h4J.5641$fZ.619@fx06.iad> |
| In reply to | #39960 |
On 9/26/21 11:16 PM, olcott wrote:
> On 9/26/2021 9:41 PM, André G. Isaak wrote:
>> On 2021-09-26 20:03, olcott wrote:
>>> On 9/26/2021 8:40 PM, André G. Isaak wrote:
>>>> On 2021-09-26 18:07, olcott wrote:
>>>>> On 9/26/2021 2:40 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/26/21 2:39 PM, olcott wrote:
>>>>>>> On 9/26/2021 1:34 PM, Richard Damon wrote:
>>>>>>>> On 9/26/21 2:28 PM, olcott wrote:
>>>>>>>>> On 9/21/2021 9:25 PM, olcott wrote:
>>>>>>>>>> void P(u8* program)
>>>>>>>>>> {
>>>>>>>>>> u8* input;
>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>> u32 Input_Halts = halt_decider(program, input);
>>>>>>>>>> if (Input_Halts)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> u8* program = (u8*)Allocate(1024);
>>>>>>>>>> u8* input;
>>>>>>>>>> CopyMemory3((u8*)P, (u8*)program);
>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>> Output("Input_Halts = ", halt_decider(program, input));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> As with my other proofs the halt status is correctly decided.
>>>>>>>>>>
>>>>>>>>>> This paper will be completely rewritten with my new findings
>>>>>>>>>> as soon
>>>>>>>>>> as they are fully operational. The key feasibility test
>>>>>>>>>> elements are
>>>>>>>>>> already fully operational. The architectural design is complete.
>>>>>>>>>>
>>>>>>>>>> To the best of my current knowledge the only steps required to
>>>>>>>>>> make
>>>>>>>>>> this system fully operational are relatively minor ordinary C/x86
>>>>>>>>>> operating system level programming.
>>>>>>>>>>
>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> This was my key 2016 Breakthrough:
>>>>>>>>> The halting theorem counter-examples present infinitely nested
>>>>>>>>> simulation (non-halting) behavior to every simulating halt
>>>>>>>>> decider.
>>>>>>>>>
>>>>>>>>> It looks like I will be able to reproduce my original results
>>>>>>>>> where the
>>>>>>>>> halt_decider is a pure function.
>>>>>>>>>
>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>> arguments (no
>>>>>>>>> variation with local static variables, non-local variables,
>>>>>>>>> mutable
>>>>>>>>> reference arguments or input streams).
>>>>>>>>>
>>>>>>>>> (2) The function application has no side effects (no mutation
>>>>>>>>> of local
>>>>>>>>> static variables, non-local variables, mutable reference
>>>>>>>>> arguments or
>>>>>>>>> input/output streams).
>>>>>>>>>
>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>
>>>>>>>>
>>>>>>>> *IF* that is true, then it is the equivalent of a Turing Machine.
>>>>>>>>
>>>>>>>> The next question is can you make it produce the right answer.
>>>>>>>>
>>>>>>>> H(P,P) needs to say Halting if P(P) halts, and Non-halting if
>>>>>>>> P(P) will
>>>>>>>> never Halt.
>>>>>>>>
>>>>>>>> None of this false reasoning that just because the partial
>>>>>>>> simulation
>>>>>>>> that H has performed didn't reach a Halt State is some how proof
>>>>>>>> that
>>>>>>>> the actual machine won't halt if it was run a little bit longer.
>>>>>>>>
>>>>>>>> The question of a Halt Decider is ALWAYS about the Machine
>>>>>>>> represented
>>>>>>>> by the input, and not about some partial simulation that the
>>>>>>>> decider has
>>>>>>>> done.
>>>>>>>>
>>>>>>>
>>>>>>> This is the part where your understanding is abysmal. An infinite
>>>>>>> simulation of P(P) never reaches the final state of P at 0x187c.
>>>>>>>
>>>>>>> _P()
>>>>>>> [00001862](01) 55 push ebp
>>>>>>> [00001863](02) 8bec mov ebp,esp
>>>>>>> [00001865](03) 8b4508 mov eax,[ebp+08]
>>>>>>> [00001868](01) 50 push eax
>>>>>>> [00001869](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>> [0000186c](01) 51 push ecx
>>>>>>> [0000186d](05) e810fdffff call 00001582
>>>>>>> [00001872](03) 83c408 add esp,+08
>>>>>>> [00001875](02) 85c0 test eax,eax
>>>>>>> [00001877](02) 7402 jz 0000187b
>>>>>>> [00001879](02) ebfe jmp 00001879
>>>>>>> [0000187b](01) 5d pop ebp
>>>>>>> [0000187c](01) c3 ret
>>>>>>> Size in bytes:(0027) [0000187c]
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> It doesn't matter if the PARTIAL simulation of P by H never gets
>>>>>> there.
>>>>>> That just shows that H decided to give up too soon.
>>>>>>
>>>>>
>>>>> I don't see how you can construe infinite simulation as partial
>>>>> simulation without you having some sort of brain damage.
>>>>
>>>> If there were actually 'infinite simulation' going on then your H(P,
>>>> P) wouldn't be able to give an answer and thus would not be a decider.
>>>>
>>>
>>> If H aborts its simulation of P(P) P never reaches its final state of
>>> 0x187c. P never gets past its state of 0x186d.
>>
>> If H aborts its simulation, then H does *not* involve infinite
>> recursive simulation, your claims to the contrary notwithstanding.
>>
>> When a simulated computation doesn't reach its final state because it
>> is aborted, that tells us nothing about whether the simulated
>> computation is halting.
>
>> Had the simulation been allowed to continue you would find that the
>> simulated P(P) would abort its input just as H(P, P) does, meaning
>> that P(P) is a halting computation.
>>
>>> If H If H NEVER aborts its simulation of P(P) P never reaches its
>>> final state of 0x187c. P never gets past its state of 0x186d.
>>
>> If H never aborts its simulation, then you are talking about a
>> *different* program from your H. What happens in that other program
>> has no relevance to your H.
>>
>
> Whether or not H aborts its simulation of P(P), the input to H(P,P)
> never reaches its final state therefore we can know that the input to
> H(P,P) is definitely not a halting computation.
>
> Since I know that you are neither stupid enough or ignorant enough to
> not know this that only leaves liar.
>
There you go with that bad terminology to confuse things.
INPUTS don't do anything.
The Machine the input represents does reach its final state, so that
machine is Halting, and the input represents a Halting Computation.
YOU seem to be by 'the input', H's processing of this input, H's
simulation of the machine that the input represents.
Yes, the simulation never reaches the final halting state, but what your
mind just can't seem to comprehend is that we understand that, but it
just doesn't matter, because the question is NOT about what the partial
simulation that H does, but what the actual machine does.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-27 09:27 -0500 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <jNednfg8uuxKScz8nZ2dnUU7-a-dnZ2d@giganews.com> |
| In reply to | #39965 |
On 9/27/2021 5:33 AM, Richard Damon wrote:
> On 9/26/21 11:16 PM, olcott wrote:
>> On 9/26/2021 9:41 PM, André G. Isaak wrote:
>>> On 2021-09-26 20:03, olcott wrote:
>>>> On 9/26/2021 8:40 PM, André G. Isaak wrote:
>>>>> On 2021-09-26 18:07, olcott wrote:
>>>>>> On 9/26/2021 2:40 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/26/21 2:39 PM, olcott wrote:
>>>>>>>> On 9/26/2021 1:34 PM, Richard Damon wrote:
>>>>>>>>> On 9/26/21 2:28 PM, olcott wrote:
>>>>>>>>>> On 9/21/2021 9:25 PM, olcott wrote:
>>>>>>>>>>> void P(u8* program)
>>>>>>>>>>> {
>>>>>>>>>>> u8* input;
>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>> u32 Input_Halts = halt_decider(program, input);
>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> u8* program = (u8*)Allocate(1024);
>>>>>>>>>>> u8* input;
>>>>>>>>>>> CopyMemory3((u8*)P, (u8*)program);
>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>> Output("Input_Halts = ", halt_decider(program, input));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> As with my other proofs the halt status is correctly decided.
>>>>>>>>>>>
>>>>>>>>>>> This paper will be completely rewritten with my new findings
>>>>>>>>>>> as soon
>>>>>>>>>>> as they are fully operational. The key feasibility test
>>>>>>>>>>> elements are
>>>>>>>>>>> already fully operational. The architectural design is complete.
>>>>>>>>>>>
>>>>>>>>>>> To the best of my current knowledge the only steps required to
>>>>>>>>>>> make
>>>>>>>>>>> this system fully operational are relatively minor ordinary C/x86
>>>>>>>>>>> operating system level programming.
>>>>>>>>>>>
>>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> This was my key 2016 Breakthrough:
>>>>>>>>>> The halting theorem counter-examples present infinitely nested
>>>>>>>>>> simulation (non-halting) behavior to every simulating halt
>>>>>>>>>> decider.
>>>>>>>>>>
>>>>>>>>>> It looks like I will be able to reproduce my original results
>>>>>>>>>> where the
>>>>>>>>>> halt_decider is a pure function.
>>>>>>>>>>
>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>> arguments (no
>>>>>>>>>> variation with local static variables, non-local variables,
>>>>>>>>>> mutable
>>>>>>>>>> reference arguments or input streams).
>>>>>>>>>>
>>>>>>>>>> (2) The function application has no side effects (no mutation
>>>>>>>>>> of local
>>>>>>>>>> static variables, non-local variables, mutable reference
>>>>>>>>>> arguments or
>>>>>>>>>> input/output streams).
>>>>>>>>>>
>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *IF* that is true, then it is the equivalent of a Turing Machine.
>>>>>>>>>
>>>>>>>>> The next question is can you make it produce the right answer.
>>>>>>>>>
>>>>>>>>> H(P,P) needs to say Halting if P(P) halts, and Non-halting if
>>>>>>>>> P(P) will
>>>>>>>>> never Halt.
>>>>>>>>>
>>>>>>>>> None of this false reasoning that just because the partial
>>>>>>>>> simulation
>>>>>>>>> that H has performed didn't reach a Halt State is some how proof
>>>>>>>>> that
>>>>>>>>> the actual machine won't halt if it was run a little bit longer.
>>>>>>>>>
>>>>>>>>> The question of a Halt Decider is ALWAYS about the Machine
>>>>>>>>> represented
>>>>>>>>> by the input, and not about some partial simulation that the
>>>>>>>>> decider has
>>>>>>>>> done.
>>>>>>>>>
>>>>>>>>
>>>>>>>> This is the part where your understanding is abysmal. An infinite
>>>>>>>> simulation of P(P) never reaches the final state of P at 0x187c.
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [00001862](01) 55 push ebp
>>>>>>>> [00001863](02) 8bec mov ebp,esp
>>>>>>>> [00001865](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [00001868](01) 50 push eax
>>>>>>>> [00001869](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [0000186c](01) 51 push ecx
>>>>>>>> [0000186d](05) e810fdffff call 00001582
>>>>>>>> [00001872](03) 83c408 add esp,+08
>>>>>>>> [00001875](02) 85c0 test eax,eax
>>>>>>>> [00001877](02) 7402 jz 0000187b
>>>>>>>> [00001879](02) ebfe jmp 00001879
>>>>>>>> [0000187b](01) 5d pop ebp
>>>>>>>> [0000187c](01) c3 ret
>>>>>>>> Size in bytes:(0027) [0000187c]
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> It doesn't matter if the PARTIAL simulation of P by H never gets
>>>>>>> there.
>>>>>>> That just shows that H decided to give up too soon.
>>>>>>>
>>>>>>
>>>>>> I don't see how you can construe infinite simulation as partial
>>>>>> simulation without you having some sort of brain damage.
>>>>>
>>>>> If there were actually 'infinite simulation' going on then your H(P,
>>>>> P) wouldn't be able to give an answer and thus would not be a decider.
>>>>>
>>>>
>>>> If H aborts its simulation of P(P) P never reaches its final state of
>>>> 0x187c. P never gets past its state of 0x186d.
>>>
>>> If H aborts its simulation, then H does *not* involve infinite
>>> recursive simulation, your claims to the contrary notwithstanding.
>>>
>>> When a simulated computation doesn't reach its final state because it
>>> is aborted, that tells us nothing about whether the simulated
>>> computation is halting.
>>
>>> Had the simulation been allowed to continue you would find that the
>>> simulated P(P) would abort its input just as H(P, P) does, meaning
>>> that P(P) is a halting computation.
>>>
>>>> If H If H NEVER aborts its simulation of P(P) P never reaches its
>>>> final state of 0x187c. P never gets past its state of 0x186d.
>>>
>>> If H never aborts its simulation, then you are talking about a
>>> *different* program from your H. What happens in that other program
>>> has no relevance to your H.
>>>
>>
>> Whether or not H aborts its simulation of P(P), the input to H(P,P)
>> never reaches its final state therefore we can know that the input to
>> H(P,P) is definitely not a halting computation.
>>
>> Since I know that you are neither stupid enough or ignorant enough to
>> not know this that only leaves liar.
>>
>
> There you go with that bad terminology to confuse things.
>
> INPUTS don't do anything.
>
The context is always the simulation of the input by a simulating halt
decider, thus simulated inputs do have behavior. That you can't keep
track of this context is pretty lame.
--
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 20:12 -0400 |
| Subject | Re: It looks like I can exactly duplicate the Linz proof in C/x86 as a pure function |
| Message-ID | <P5t4J.139776$Kv2.108857@fx47.iad> |
| In reply to | #39969 |
On 9/27/21 10:27 AM, olcott wrote:
> On 9/27/2021 5:33 AM, Richard Damon wrote:
>> On 9/26/21 11:16 PM, olcott wrote:
>>> On 9/26/2021 9:41 PM, André G. Isaak wrote:
>>>> On 2021-09-26 20:03, olcott wrote:
>>>>> On 9/26/2021 8:40 PM, André G. Isaak wrote:
>>>>>> On 2021-09-26 18:07, olcott wrote:
>>>>>>> On 9/26/2021 2:40 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/26/21 2:39 PM, olcott wrote:
>>>>>>>>> On 9/26/2021 1:34 PM, Richard Damon wrote:
>>>>>>>>>> On 9/26/21 2:28 PM, olcott wrote:
>>>>>>>>>>> On 9/21/2021 9:25 PM, olcott wrote:
>>>>>>>>>>>> void P(u8* program)
>>>>>>>>>>>> {
>>>>>>>>>>>> u8* input;
>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>> u32 Input_Halts = halt_decider(program, input);
>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> u8* program = (u8*)Allocate(1024);
>>>>>>>>>>>> u8* input;
>>>>>>>>>>>> CopyMemory3((u8*)P, (u8*)program);
>>>>>>>>>>>> CopyMemory(program, input);
>>>>>>>>>>>> Output("Input_Halts = ", halt_decider(program, input));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> As with my other proofs the halt status is correctly decided.
>>>>>>>>>>>>
>>>>>>>>>>>> This paper will be completely rewritten with my new findings
>>>>>>>>>>>> as soon
>>>>>>>>>>>> as they are fully operational. The key feasibility test
>>>>>>>>>>>> elements are
>>>>>>>>>>>> already fully operational. The architectural design is
>>>>>>>>>>>> complete.
>>>>>>>>>>>>
>>>>>>>>>>>> To the best of my current knowledge the only steps required to
>>>>>>>>>>>> make
>>>>>>>>>>>> this system fully operational are relatively minor ordinary
>>>>>>>>>>>> C/x86
>>>>>>>>>>>> operating system level programming.
>>>>>>>>>>>>
>>>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> This was my key 2016 Breakthrough:
>>>>>>>>>>> The halting theorem counter-examples present infinitely nested
>>>>>>>>>>> simulation (non-halting) behavior to every simulating halt
>>>>>>>>>>> decider.
>>>>>>>>>>>
>>>>>>>>>>> It looks like I will be able to reproduce my original results
>>>>>>>>>>> where the
>>>>>>>>>>> halt_decider is a pure function.
>>>>>>>>>>>
>>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>>> arguments (no
>>>>>>>>>>> variation with local static variables, non-local variables,
>>>>>>>>>>> mutable
>>>>>>>>>>> reference arguments or input streams).
>>>>>>>>>>>
>>>>>>>>>>> (2) The function application has no side effects (no mutation
>>>>>>>>>>> of local
>>>>>>>>>>> static variables, non-local variables, mutable reference
>>>>>>>>>>> arguments or
>>>>>>>>>>> input/output streams).
>>>>>>>>>>>
>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *IF* that is true, then it is the equivalent of a Turing Machine.
>>>>>>>>>>
>>>>>>>>>> The next question is can you make it produce the right answer.
>>>>>>>>>>
>>>>>>>>>> H(P,P) needs to say Halting if P(P) halts, and Non-halting if
>>>>>>>>>> P(P) will
>>>>>>>>>> never Halt.
>>>>>>>>>>
>>>>>>>>>> None of this false reasoning that just because the partial
>>>>>>>>>> simulation
>>>>>>>>>> that H has performed didn't reach a Halt State is some how proof
>>>>>>>>>> that
>>>>>>>>>> the actual machine won't halt if it was run a little bit longer.
>>>>>>>>>>
>>>>>>>>>> The question of a Halt Decider is ALWAYS about the Machine
>>>>>>>>>> represented
>>>>>>>>>> by the input, and not about some partial simulation that the
>>>>>>>>>> decider has
>>>>>>>>>> done.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> This is the part where your understanding is abysmal. An infinite
>>>>>>>>> simulation of P(P) never reaches the final state of P at 0x187c.
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [00001862](01) 55 push ebp
>>>>>>>>> [00001863](02) 8bec mov ebp,esp
>>>>>>>>> [00001865](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00001868](01) 50 push eax
>>>>>>>>> [00001869](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [0000186c](01) 51 push ecx
>>>>>>>>> [0000186d](05) e810fdffff call 00001582
>>>>>>>>> [00001872](03) 83c408 add esp,+08
>>>>>>>>> [00001875](02) 85c0 test eax,eax
>>>>>>>>> [00001877](02) 7402 jz 0000187b
>>>>>>>>> [00001879](02) ebfe jmp 00001879
>>>>>>>>> [0000187b](01) 5d pop ebp
>>>>>>>>> [0000187c](01) c3 ret
>>>>>>>>> Size in bytes:(0027) [0000187c]
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> It doesn't matter if the PARTIAL simulation of P by H never gets
>>>>>>>> there.
>>>>>>>> That just shows that H decided to give up too soon.
>>>>>>>>
>>>>>>>
>>>>>>> I don't see how you can construe infinite simulation as partial
>>>>>>> simulation without you having some sort of brain damage.
>>>>>>
>>>>>> If there were actually 'infinite simulation' going on then your H(P,
>>>>>> P) wouldn't be able to give an answer and thus would not be a
>>>>>> decider.
>>>>>>
>>>>>
>>>>> If H aborts its simulation of P(P) P never reaches its final state of
>>>>> 0x187c. P never gets past its state of 0x186d.
>>>>
>>>> If H aborts its simulation, then H does *not* involve infinite
>>>> recursive simulation, your claims to the contrary notwithstanding.
>>>>
>>>> When a simulated computation doesn't reach its final state because it
>>>> is aborted, that tells us nothing about whether the simulated
>>>> computation is halting.
>>>
>>>> Had the simulation been allowed to continue you would find that the
>>>> simulated P(P) would abort its input just as H(P, P) does, meaning
>>>> that P(P) is a halting computation.
>>>>
>>>>> If H If H NEVER aborts its simulation of P(P) P never reaches its
>>>>> final state of 0x187c. P never gets past its state of 0x186d.
>>>>
>>>> If H never aborts its simulation, then you are talking about a
>>>> *different* program from your H. What happens in that other program
>>>> has no relevance to your H.
>>>>
>>>
>>> Whether or not H aborts its simulation of P(P), the input to H(P,P)
>>> never reaches its final state therefore we can know that the input to
>>> H(P,P) is definitely not a halting computation.
>>>
>>> Since I know that you are neither stupid enough or ignorant enough to
>>> not know this that only leaves liar.
>>>
>>
>> There you go with that bad terminology to confuse things.
>>
>> INPUTS don't do anything.
>>
>
> The context is always the simulation of the input by a simulating halt
> decider, thus simulated inputs do have behavior. That you can't keep
> track of this context is pretty lame.
>
>
Then you have the wrong context. THe Question for H, if you want to be
be talking about a Halt Decider, is does the ACTUAL MACHINE represented
by the input halt if it is run with the input given.
The Halting problem doesn't care about H's partial simulation.
The context that you seem to be interested is just POOP.
[toc] | [prev] | [standalone]
Page 12 of 12 — ← Prev page 1 … 10 11 [12]
Back to top | Article view | comp.theory
csiph-web