Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #39388 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-09-17 21:40 -0500 |
| Last post | 2021-09-19 23:11 +0100 |
| Articles | 20 on this page of 243 — 10 participants |
Back to article view | Back to comp.theory
Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-17 21:40 -0500
Re: Why do theory of computation problems require pure functions? "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-09-17 21:48 -0700
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-17 22:50 -0600
Re: Why do theory of computation problems require pure functions? Jeff Barnett <jbb@notatt.com> - 2021-09-18 00:02 -0600
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 00:13 -0600
Re: Why do theory of computation problems require pure functions? Jeff Barnett <jbb@notatt.com> - 2021-09-18 00:29 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 08:54 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 10:43 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 09:49 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 09:02 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:13 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:23 -0400
Re: Why do theory of computation problems require pure functions? olcott <polcott2@gmail.com> - 2021-09-18 10:28 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:42 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:51 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 12:00 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:34 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 10:29 -0600
Re: Why do theory of computation problems require pure functions? Jeff Barnett <jbb@notatt.com> - 2021-09-18 11:31 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 12:47 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:34 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:45 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 16:06 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 15:20 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 21:46 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 16:06 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:14 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 22:58 +0100
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:04 -0400
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:13 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:19 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:25 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:37 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:44 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:08 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 12:32 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 12:04 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:12 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:02 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 16:11 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:30 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 23:03 +0100
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 09:01 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:10 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 10:09 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:36 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 07:14 -0400
Re: Why do theory of computation problems require pure functions? Andy Walker <anw@cuboid.co.uk> - 2021-09-18 13:02 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 08:57 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 10:53 -0400
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 09:04 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:17 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:24 -0400
Re: Why do theory of computation problems require pure functions? olcott <polcott2@gmail.com> - 2021-09-18 10:29 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:37 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 10:39 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 11:52 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:15 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 12:28 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:50 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:08 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:30 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:52 -0400
Re: Why do theory of computation problems require pure functions? [mow lawn] olcott <NoOne@NoWhere.com> - 2021-09-18 15:07 -0500
Re: Why do theory of computation problems require pure functions? [mow lawn] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 16:55 -0400
Re: Why do theory of computation problems require pure functions? [mow lawn] olcott <NoOne@NoWhere.com> - 2021-09-18 16:22 -0500
Re: Why do theory of computation problems require pure functions? [mow lawn] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:38 -0400
Re: Why do theory of computation problems require pure functions? [mow lawn] olcott <NoOne@NoWhere.com> - 2021-09-18 16:48 -0500
Re: Why do theory of computation problems require pure functions? [mow lawn] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:01 -0400
Re: Why do theory of computation problems require pure functions? [defeat Rice] olcott <NoOne@NoWhere.com> - 2021-09-18 17:10 -0500
Re: Why do theory of computation problems require pure functions? [defeat Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:26 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:55 +0100
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 10:10 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 11:39 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 10:52 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 12:08 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:24 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:39 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:57 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 15:17 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 16:45 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 15:55 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:11 -0400
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 16:08 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 17:15 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 16:28 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 17:32 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 16:55 -0600
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:58 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 17:58 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 19:09 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 22:32 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 22:10 -0600
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 22:19 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 00:12 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 00:00 -0600
Re: Why do theory of computation problems require pure functions?[ decidability decider citation ] olcott <NoOne@NoWhere.com> - 2021-09-19 06:56 -0500
Re: Why do theory of computation problems require pure functions?[ decidability decider citation ] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 08:05 -0600
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 06:28 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 09:34 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 09:40 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 10:46 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 10:11 -0600
Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 11:39 -0500
Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 10:56 -0600
Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 12:07 -0500
Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 11:25 -0600
Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 12:54 -0500
Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 12:24 -0600
Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 13:33 -0500
Re: Why do theory of computation problems require pure functions? [ PSR error] Richard Damon <Richard@Damon-Family.org> - 2021-09-19 15:11 -0400
Re: Why do theory of computation problems require pure functions? [ PSR error] Andy Walker <anw@cuboid.co.uk> - 2021-09-19 20:22 +0100
Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 14:31 -0500
Re: Why do theory of computation problems require pure functions? [ PSR error] Andy Walker <anw@cuboid.co.uk> - 2021-09-19 21:39 +0100
Re: Why do theory of computation problems require pure functions? [ PSR error] Richard Damon <Richard@Damon-Family.org> - 2021-09-19 18:59 -0400
Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 13:23 -0600
Re: Why do theory of computation problems require pure functions? [ PSR error] olcott <NoOne@NoWhere.com> - 2021-09-19 14:37 -0500
Re: Why do theory of computation problems require pure functions? [ PSR error] André G. Isaak <agisaak@gm.invalid> - 2021-09-19 13:45 -0600
Re: Why do theory of computation problems require pure functions? [ PSR error] Andy Walker <anw@cuboid.co.uk> - 2021-09-19 21:33 +0100
Re: Why do theory of computation problems require pure functions? [ PSR error] Jeff Barnett <jbb@notatt.com> - 2021-09-19 11:36 -0600
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 13:37 -0400
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 06:31 -0400
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 17:14 -0600
Re: Why do theory of computation problems require pure functions? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-18 16:11 -0700
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-18 17:16 -0600
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 22:52 +0100
Re: Why do theory of computation problems require pure functions? [ Bingo !] olcott <NoOne@NoWhere.com> - 2021-09-18 18:17 -0500
Re: Why do theory of computation problems require pure functions? [ Bingo !] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 19:20 -0400
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 19:17 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 22:38 +0100
Re: Why do theory of computation problems require pure functions? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-19 15:36 -0700
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 00:01 +0100
Re: Why do theory of computation problems require pure functions? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-19 16:23 -0700
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 00:37 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 20:49 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 10:54 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 08:58 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:02 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 20:21 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 11:00 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 09:21 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 23:06 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 18:33 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 01:00 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 19:14 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 01:56 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 20:11 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 02:45 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 20:49 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:30 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 21:38 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:50 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 22:09 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:29 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-22 01:44 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-21 19:56 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-22 23:58 +0100
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:05 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 22:13 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:35 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-21 10:21 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-21 22:12 -0400
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:16 -0400
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:12 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-20 21:25 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:21 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-20 23:03 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 00:42 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-20 23:55 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 01:17 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 08:23 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 10:19 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] André G. Isaak <agisaak@gm.invalid> - 2021-09-21 11:51 -0600
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 13:22 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] André G. Isaak <agisaak@gm.invalid> - 2021-09-21 12:43 -0600
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 14:25 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 21:33 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] André G. Isaak <agisaak@gm.invalid> - 2021-09-21 21:45 -0600
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 23:05 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-22 07:03 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] André G. Isaak <agisaak@gm.invalid> - 2021-09-22 14:46 -0600
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-22 15:52 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-22 19:55 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 19:23 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 19:21 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 18:56 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 21:39 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-22 08:01 -0400
Re: Why do theory of computation problems require pure functions? [ computation ? ] olcott <NoOne@NoWhere.com> - 2021-09-21 10:16 -0500
Re: Why do theory of computation problems require pure functions? [ computation ? ] Richard Damon <Richard@Damon-Family.org> - 2021-09-21 22:10 -0400
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 21:28 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 20:33 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:21 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 21:35 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:45 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 22:07 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:24 -0400
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:04 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 20:18 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 19:48 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 21:00 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 22:10 -0400
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 20:20 -0600
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-19 21:55 -0500
Re: Why do theory of computation problems require pure functions? André G. Isaak <agisaak@gm.invalid> - 2021-09-19 22:16 -0600
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 06:47 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-20 09:22 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:19 -0400
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 22:15 -0400
Re: Why do theory of computation problems require pure functions? Jeff Barnett <jbb@notatt.com> - 2021-09-18 18:21 -0600
Re: Why do theory of computation problems require pure functions? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-09-19 03:15 +0100
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:29 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:54 +0100
Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-18 17:02 -0500
Re: Why do theory of computation problems require pure functions? [defeating Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:24 -0400
Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-18 17:29 -0500
Re: Why do theory of computation problems require pure functions? [defeating Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:35 -0400
Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 00:43 +0100
Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-19 20:56 -0500
Re: Why do theory of computation problems require pure functions? [defeating Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-19 22:22 -0400
Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 10:54 +0100
Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-20 09:02 -0500
Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 23:05 +0100
Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-20 18:37 -0500
Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 01:43 +0100
Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-20 19:51 -0500
Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:10 +0100
Re: Why do theory of computation problems require pure functions? [defeating Rice] Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:27 -0400
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 18:32 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 22:07 +0100
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 14:55 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:06 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 15:40 -0400
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 14:52 -0500
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 16:15 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:51 +0100
Re: Why do theory of computation problems require pure functions? olcott <NoOne@NoWhere.com> - 2021-09-18 17:00 -0500
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 23:26 +0100
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 22:45 +0100
Re: Why do theory of computation problems require pure functions? Richard Damon <Richard@Damon-Family.org> - 2021-09-18 17:51 -0400
Re: Why do theory of computation problems require pure functions? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-18 23:24 +0100
Re: Why do theory of computation problems require pure functions? [defeating Rice] olcott <NoOne@NoWhere.com> - 2021-09-18 16:57 -0500
Re: Why do theory of computation problems require pure functions? [defeating Rice] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 23:11 +0100
Page 4 of 13 — ← Prev page 1 2 3 [4] 5 6 … 13 Next page →
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-18 15:08 -0400 |
| Message-ID | <GOq1J.79024$g81.54978@fx33.iad> |
| In reply to | #39433 |
On 9/18/21 12:50 PM, olcott wrote: > On 9/18/2021 11:28 AM, Richard Damon wrote: >> On 9/18/21 12:15 PM, olcott wrote: >>> On 9/18/2021 10:52 AM, Richard Damon wrote: >>>> On 9/18/21 11:39 AM, olcott wrote: >>>>> On 9/18/2021 10:37 AM, Richard Damon wrote: >>>>>> On 9/18/21 11:29 AM, olcott wrote: >>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote: >>>>>>>> On 9/18/21 11:17 AM, olcott wrote: >>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>>> >>>>>>>>>>> I either must stick with C/x86 code or write a RASP machine, the >>>>>>>>>>> only >>>>>>>>>>> way that my key insights can possible be fully understood is to >>>>>>>>>>> have >>>>>>>>>>> every single detail as fully operational code such that we can >>>>>>>>>>> simply >>>>>>>>>>> see what it does and thus not merely imagine what it would do. >>>>>>>>>> >>>>>>>>>> Why do you insist on continuously repeating this rather >>>>>>>>>> ridiculous >>>>>>>>>> claim? >>>>>>>>>> >>>>>>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>>>>>> imagine >>>>>>>>>> what it would do.' One can see *exactly* what it does. >>>>>>>>>> >>>>>>>>>> André >>>>>>>>>> >>>>>>>>> >>>>>>>>> When H is defined as a simulating halt decider then H correctly >>>>>>>>> decides >>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>> >>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf >>>>>>>>> >>>>>>>> >>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting when it >>>>>>>> actually >>>>>>>> Halts. >>>>>>>> >>>>>>> >>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. >>>>>>> >>>>>> >>>>>> Which says that it is deciding that H^(<H^>) is a non-halting >>>>>> computation, but if we run H^(<H^>) it ends up at its terminal state >>>>>> H^.qy which halts. (Since the code for H^ is derived from the code >>>>>> of H, >>>>>> and the state H^.qn is the corresponding state to H.qn) >>>>>> >>>>> >>>>> So does my use of a static local variable by itself make my code not >>>>> apply to the halting problem or not? >>>>> >>>> >>>> No, but that doesn't mean that the presence of the static local >>>> variable >>>> is unconditionally allowed. >>>> >>>> You need to PROVE that your program is a Computation. >>>> >>>> Lack of things like static local variables make that proof much easier. >>>> as if all information inside the program can only be derived from the >>>> official input, then there is no source of 'illegal' information. >>>> >>> >>> The halt status decision is entirely based on the execution trace >>> derived from the input machine address pair. >> >> Right, but that ALSO applies to the simulated copies of H, which need to >> give the exact same answer given the exact same input. >> > > The original way that it worked was that the very first slave that saw > that an infinite behavior pattern was matched reported this through a > static variable that every master/slave instance of H used as their > while (**Aborted == 0) termination condition. > > Then I changed this so that only the master made the halt status > decision. Its trigger for testing the halt status was that the local > static execution trace is longer than it was the last time that it > tested the halt status. The key is that the system needs to be setup so that each of the 'slave' H's would also generate that exact same answer if the outer copy (and just that copy) is modified to not abort to allow the testing of it being right in deciding to abort. > >> This means that since the 'master' H(P,P) returns non-halting, that must >> be consistent with the copy of H inside P ALSO return the answer of >> non-halting when given that exact same input. >> >> The 'assumption' that it will not return is a violation of that. >> >> Either H is using unsound logic, or H is not a computation because the >> 'slave' H doesn't behave the same way. >> >>> >>>> Presence of things like static local variables don't by themselves >>>> invalidate you ability to be a Computation, but do mean you really do >>>> need to show that it is one. >>>> >>> >>> That is great. What are the requirements of a computation? >>> >>> given an input of the function domain it can return the corresponding >>> output. https://en.wikipedia.org/wiki/Computable_function >> >> It is a bit more that a function with a specific value for a specific >> input, as it also needs to be the results of an 'algorithm', a step by >> step listing of instructions to get to the result. >> >> If all of the inputs to the algorithm are part of the formal input to >> the function, then you get a computation. >> > > Formal input is typically restricted to input parameters. > The use of the static local execution_trace is to store intermediate > results that are derived on the basis of the input parameters. Watch out, input parameters are for THAT INSTANCE, so a slave instance can't act differently (as far as its caller can tell) just because it is a slave instance. Remember each instance represents its own computation, and that computation must generate that same answer for the same inputs. > >>> >>>> So, as of now, the proposition that your code is eligible to be a >>>> decider is unproven, and can not just be 'assumed' >>>> >>>> If we ever see a case where two copies of H given the same input act >>>> differently, then this statement is proved in the negative. >>>> >>> >>> >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-18 14:30 -0500 |
| Message-ID | <psOdneKsN-zIo9v8nZ2dnUU7-K3NnZ2d@giganews.com> |
| In reply to | #39442 |
On 9/18/2021 2:08 PM, Richard Damon wrote: > On 9/18/21 12:50 PM, olcott wrote: >> On 9/18/2021 11:28 AM, Richard Damon wrote: >>> On 9/18/21 12:15 PM, olcott wrote: >>>> On 9/18/2021 10:52 AM, Richard Damon wrote: >>>>> On 9/18/21 11:39 AM, olcott wrote: >>>>>> On 9/18/2021 10:37 AM, Richard Damon wrote: >>>>>>> On 9/18/21 11:29 AM, olcott wrote: >>>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote: >>>>>>>>> On 9/18/21 11:17 AM, olcott wrote: >>>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>>>> >>>>>>>>>>>> I either must stick with C/x86 code or write a RASP machine, the >>>>>>>>>>>> only >>>>>>>>>>>> way that my key insights can possible be fully understood is to >>>>>>>>>>>> have >>>>>>>>>>>> every single detail as fully operational code such that we can >>>>>>>>>>>> simply >>>>>>>>>>>> see what it does and thus not merely imagine what it would do. >>>>>>>>>>> >>>>>>>>>>> Why do you insist on continuously repeating this rather >>>>>>>>>>> ridiculous >>>>>>>>>>> claim? >>>>>>>>>>> >>>>>>>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>>>>>>> imagine >>>>>>>>>>> what it would do.' One can see *exactly* what it does. >>>>>>>>>>> >>>>>>>>>>> André >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> When H is defined as a simulating halt decider then H correctly >>>>>>>>>> decides >>>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>> >>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf >>>>>>>>>> >>>>>>>>> >>>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting when it >>>>>>>>> actually >>>>>>>>> Halts. >>>>>>>>> >>>>>>>> >>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. >>>>>>>> >>>>>>> >>>>>>> Which says that it is deciding that H^(<H^>) is a non-halting >>>>>>> computation, but if we run H^(<H^>) it ends up at its terminal state >>>>>>> H^.qy which halts. (Since the code for H^ is derived from the code >>>>>>> of H, >>>>>>> and the state H^.qn is the corresponding state to H.qn) >>>>>>> >>>>>> >>>>>> So does my use of a static local variable by itself make my code not >>>>>> apply to the halting problem or not? >>>>>> >>>>> >>>>> No, but that doesn't mean that the presence of the static local >>>>> variable >>>>> is unconditionally allowed. >>>>> >>>>> You need to PROVE that your program is a Computation. >>>>> >>>>> Lack of things like static local variables make that proof much easier. >>>>> as if all information inside the program can only be derived from the >>>>> official input, then there is no source of 'illegal' information. >>>>> >>>> >>>> The halt status decision is entirely based on the execution trace >>>> derived from the input machine address pair. >>> >>> Right, but that ALSO applies to the simulated copies of H, which need to >>> give the exact same answer given the exact same input. >>> >> >> The original way that it worked was that the very first slave that saw >> that an infinite behavior pattern was matched reported this through a >> static variable that every master/slave instance of H used as their >> while (**Aborted == 0) termination condition. >> >> Then I changed this so that only the master made the halt status >> decision. Its trigger for testing the halt status was that the local >> static execution trace is longer than it was the last time that it >> tested the halt status. > > The key is that the system needs to be setup so that each of the 'slave' > H's would also generate that exact same answer if the outer copy (and > just that copy) is modified to not abort to allow the testing of it > being right in deciding to abort. > The inner and outer generate the exact same answer. The inner used to generate the answer and now the outer generates the same answer. If I don't force it to decide at a certain point then the inner one that reports that its input never halts is the one that has reached the deepest recursion depth and thus sees more of the execution trace before the other ones. >> >>> This means that since the 'master' H(P,P) returns non-halting, that must >>> be consistent with the copy of H inside P ALSO return the answer of >>> non-halting when given that exact same input. >>> >>> The 'assumption' that it will not return is a violation of that. >>> >>> Either H is using unsound logic, or H is not a computation because the >>> 'slave' H doesn't behave the same way. >>> >>>> >>>>> Presence of things like static local variables don't by themselves >>>>> invalidate you ability to be a Computation, but do mean you really do >>>>> need to show that it is one. >>>>> >>>> >>>> That is great. What are the requirements of a computation? >>>> >>>> given an input of the function domain it can return the corresponding >>>> output. https://en.wikipedia.org/wiki/Computable_function >>> >>> It is a bit more that a function with a specific value for a specific >>> input, as it also needs to be the results of an 'algorithm', a step by >>> step listing of instructions to get to the result. >>> >>> If all of the inputs to the algorithm are part of the formal input to >>> the function, then you get a computation. >>> >> >> Formal input is typically restricted to input parameters. >> The use of the static local execution_trace is to store intermediate >> results that are derived on the basis of the input parameters. > > Watch out, input parameters are for THAT INSTANCE, so a slave instance > can't act differently (as far as its caller can tell) just because it is > a slave instance. Yet in this case that is simply factually incorrect. The deeper that the recursive simulation goes the longer the execution trace becomes. As soon as the execution trace is long enough to match an infinitely repeating pattern simulation is aborted. Without a static local variable it is impossible for the halt decider to see that it has ever been invoked more than once. Without a static local variable every time that it is invoked its execution trace is emptied. > Remember each instance represents its own computation, > and that computation must generate that same answer for the same inputs. > That seems to mean that every function called in infinite recursion is not allowed to keep track that it was called in infinite recursion. >> >>>> >>>>> So, as of now, the proposition that your code is eligible to be a >>>>> decider is unproven, and can not just be 'assumed' >>>>> >>>>> If we ever see a case where two copies of H given the same input act >>>>> differently, then this statement is proved in the negative. >>>>> >>>> >>>> >>> >> >> > -- 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-18 15:52 -0400 |
| Message-ID | <osr1J.96887$Kv2.60854@fx47.iad> |
| In reply to | #39445 |
On 9/18/21 3:30 PM, olcott wrote: > On 9/18/2021 2:08 PM, Richard Damon wrote: >> On 9/18/21 12:50 PM, olcott wrote: >>> On 9/18/2021 11:28 AM, Richard Damon wrote: >>>> On 9/18/21 12:15 PM, olcott wrote: >>>>> On 9/18/2021 10:52 AM, Richard Damon wrote: >>>>>> On 9/18/21 11:39 AM, olcott wrote: >>>>>>> On 9/18/2021 10:37 AM, Richard Damon wrote: >>>>>>>> On 9/18/21 11:29 AM, olcott wrote: >>>>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote: >>>>>>>>>> On 9/18/21 11:17 AM, olcott wrote: >>>>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>>>>> >>>>>>>>>>>>> I either must stick with C/x86 code or write a RASP >>>>>>>>>>>>> machine, the >>>>>>>>>>>>> only >>>>>>>>>>>>> way that my key insights can possible be fully understood >>>>>>>>>>>>> is to >>>>>>>>>>>>> have >>>>>>>>>>>>> every single detail as fully operational code such that we can >>>>>>>>>>>>> simply >>>>>>>>>>>>> see what it does and thus not merely imagine what it would do. >>>>>>>>>>>> >>>>>>>>>>>> Why do you insist on continuously repeating this rather >>>>>>>>>>>> ridiculous >>>>>>>>>>>> claim? >>>>>>>>>>>> >>>>>>>>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>>>>>>>> imagine >>>>>>>>>>>> what it would do.' One can see *exactly* what it does. >>>>>>>>>>>> >>>>>>>>>>>> André >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> When H is defined as a simulating halt decider then H correctly >>>>>>>>>>> decides >>>>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>> >>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting when it >>>>>>>>>> actually >>>>>>>>>> Halts. >>>>>>>>>> >>>>>>>>> >>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. >>>>>>>>> >>>>>>>> >>>>>>>> Which says that it is deciding that H^(<H^>) is a non-halting >>>>>>>> computation, but if we run H^(<H^>) it ends up at its terminal >>>>>>>> state >>>>>>>> H^.qy which halts. (Since the code for H^ is derived from the code >>>>>>>> of H, >>>>>>>> and the state H^.qn is the corresponding state to H.qn) >>>>>>>> >>>>>>> >>>>>>> So does my use of a static local variable by itself make my code not >>>>>>> apply to the halting problem or not? >>>>>>> >>>>>> >>>>>> No, but that doesn't mean that the presence of the static local >>>>>> variable >>>>>> is unconditionally allowed. >>>>>> >>>>>> You need to PROVE that your program is a Computation. >>>>>> >>>>>> Lack of things like static local variables make that proof much >>>>>> easier. >>>>>> as if all information inside the program can only be derived from the >>>>>> official input, then there is no source of 'illegal' information. >>>>>> >>>>> >>>>> The halt status decision is entirely based on the execution trace >>>>> derived from the input machine address pair. >>>> >>>> Right, but that ALSO applies to the simulated copies of H, which >>>> need to >>>> give the exact same answer given the exact same input. >>>> >>> >>> The original way that it worked was that the very first slave that saw >>> that an infinite behavior pattern was matched reported this through a >>> static variable that every master/slave instance of H used as their >>> while (**Aborted == 0) termination condition. >>> >>> Then I changed this so that only the master made the halt status >>> decision. Its trigger for testing the halt status was that the local >>> static execution trace is longer than it was the last time that it >>> tested the halt status. >> >> The key is that the system needs to be setup so that each of the 'slave' >> H's would also generate that exact same answer if the outer copy (and >> just that copy) is modified to not abort to allow the testing of it >> being right in deciding to abort. >> > > The inner and outer generate the exact same answer. The inner used to > generate the answer and now the outer generates the same answer. If I > don't force it to decide at a certain point then the inner one that > reports that its input never halts is the one that has reached the > deepest recursion depth and thus sees more of the execution trace before > the other ones. So, you are admitting that the slave H WILL return the Non-Halting answer in finite time and thus the H^ that called it was NOT in infinite recursion and does itself Halt in finite time? THAT is the implication that the slave H will behave exactly the same as the master. > >>> >>>> This means that since the 'master' H(P,P) returns non-halting, that >>>> must >>>> be consistent with the copy of H inside P ALSO return the answer of >>>> non-halting when given that exact same input. >>>> >>>> The 'assumption' that it will not return is a violation of that. >>>> >>>> Either H is using unsound logic, or H is not a computation because the >>>> 'slave' H doesn't behave the same way. >>>> >>>>> >>>>>> Presence of things like static local variables don't by themselves >>>>>> invalidate you ability to be a Computation, but do mean you really do >>>>>> need to show that it is one. >>>>>> >>>>> >>>>> That is great. What are the requirements of a computation? >>>>> >>>>> given an input of the function domain it can return the corresponding >>>>> output. https://en.wikipedia.org/wiki/Computable_function >>>> >>>> It is a bit more that a function with a specific value for a specific >>>> input, as it also needs to be the results of an 'algorithm', a step by >>>> step listing of instructions to get to the result. >>>> >>>> If all of the inputs to the algorithm are part of the formal input to >>>> the function, then you get a computation. >>>> >>> >>> Formal input is typically restricted to input parameters. >>> The use of the static local execution_trace is to store intermediate >>> results that are derived on the basis of the input parameters. >> >> Watch out, input parameters are for THAT INSTANCE, so a slave instance >> can't act differently (as far as its caller can tell) just because it is >> a slave instance. > > Yet in this case that is simply factually incorrect. The deeper that the > recursive simulation goes the longer the execution trace becomes. As > soon as the execution trace is long enough to match an infinitely > repeating pattern simulation is aborted. > > Without a static local variable it is impossible for the halt decider to > see that it has ever been invoked more than once. Without a static local > variable every time that it is invoked its execution trace is emptied. Again, it isn't the fact that the static local variable exist that causes the problem, but EVERY copy of the decider needs to act exactly the same to its caller when provided the exact same inputs. So the slave Hs need to be able and considered to abort their own simulations just like the master did, and thus reveal that the master was in error in assuming they would not. > >> Remember each instance represents its own computation, >> and that computation must generate that same answer for the same inputs. >> > > That seems to mean that every function called in infinite recursion is > not allowed to keep track that it was called in infinite recursion. No, it does not say that. Since every level of the decider WILL abort its simulation in a finite amount of time, there NEVER WAS an infinite recursion at any point. Only a finite number of machines were ever created and each of those, if allowed to complete themselves (without affecting the code on their tape) would complete in finite time. Every H[i] will simulate P[i+1] which calls H[i+1] which will start the simulation of P[i+2] which triggers the aborting mechanism, so NO H[i] ended up being infinity recursive, but only runs for a finite number of steps and levels. H[i] makes the error in that it THINKS P[i+1] will be infinite because H[i] doesn't take into account that H[i+1] WILL abort it simulation just like H[i] is doing, and thus it WRONGLY THINKS that P is non-halting. > >>> >>>>> >>>>>> So, as of now, the proposition that your code is eligible to be a >>>>>> decider is unproven, and can not just be 'assumed' >>>>>> >>>>>> If we ever see a case where two copies of H given the same input act >>>>>> differently, then this statement is proved in the negative. >>>>>> >>>>> >>>>> >>>> >>> >>> >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-18 15:07 -0500 |
| Subject | Re: Why do theory of computation problems require pure functions? [mow lawn] |
| Message-ID | <i8idnZQmxsuW2tv8nZ2dnUU7-ePNnZ2d@giganews.com> |
| In reply to | #39451 |
On 9/18/2021 2:52 PM, Richard Damon wrote: > On 9/18/21 3:30 PM, olcott wrote: >> On 9/18/2021 2:08 PM, Richard Damon wrote: >>> On 9/18/21 12:50 PM, olcott wrote: >>>> On 9/18/2021 11:28 AM, Richard Damon wrote: >>>>> On 9/18/21 12:15 PM, olcott wrote: >>>>>> On 9/18/2021 10:52 AM, Richard Damon wrote: >>>>>>> On 9/18/21 11:39 AM, olcott wrote: >>>>>>>> On 9/18/2021 10:37 AM, Richard Damon wrote: >>>>>>>>> On 9/18/21 11:29 AM, olcott wrote: >>>>>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote: >>>>>>>>>>> On 9/18/21 11:17 AM, olcott wrote: >>>>>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>>>>>> >>>>>>>>>>>>>> I either must stick with C/x86 code or write a RASP >>>>>>>>>>>>>> machine, the >>>>>>>>>>>>>> only >>>>>>>>>>>>>> way that my key insights can possible be fully understood >>>>>>>>>>>>>> is to >>>>>>>>>>>>>> have >>>>>>>>>>>>>> every single detail as fully operational code such that we can >>>>>>>>>>>>>> simply >>>>>>>>>>>>>> see what it does and thus not merely imagine what it would do. >>>>>>>>>>>>> >>>>>>>>>>>>> Why do you insist on continuously repeating this rather >>>>>>>>>>>>> ridiculous >>>>>>>>>>>>> claim? >>>>>>>>>>>>> >>>>>>>>>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>>>>>>>>> imagine >>>>>>>>>>>>> what it would do.' One can see *exactly* what it does. >>>>>>>>>>>>> >>>>>>>>>>>>> André >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> When H is defined as a simulating halt decider then H correctly >>>>>>>>>>>> decides >>>>>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>> >>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting when it >>>>>>>>>>> actually >>>>>>>>>>> Halts. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. >>>>>>>>>> >>>>>>>>> >>>>>>>>> Which says that it is deciding that H^(<H^>) is a non-halting >>>>>>>>> computation, but if we run H^(<H^>) it ends up at its terminal >>>>>>>>> state >>>>>>>>> H^.qy which halts. (Since the code for H^ is derived from the code >>>>>>>>> of H, >>>>>>>>> and the state H^.qn is the corresponding state to H.qn) >>>>>>>>> >>>>>>>> >>>>>>>> So does my use of a static local variable by itself make my code not >>>>>>>> apply to the halting problem or not? >>>>>>>> >>>>>>> >>>>>>> No, but that doesn't mean that the presence of the static local >>>>>>> variable >>>>>>> is unconditionally allowed. >>>>>>> >>>>>>> You need to PROVE that your program is a Computation. >>>>>>> >>>>>>> Lack of things like static local variables make that proof much >>>>>>> easier. >>>>>>> as if all information inside the program can only be derived from the >>>>>>> official input, then there is no source of 'illegal' information. >>>>>>> >>>>>> >>>>>> The halt status decision is entirely based on the execution trace >>>>>> derived from the input machine address pair. >>>>> >>>>> Right, but that ALSO applies to the simulated copies of H, which >>>>> need to >>>>> give the exact same answer given the exact same input. >>>>> >>>> >>>> The original way that it worked was that the very first slave that saw >>>> that an infinite behavior pattern was matched reported this through a >>>> static variable that every master/slave instance of H used as their >>>> while (**Aborted == 0) termination condition. >>>> >>>> Then I changed this so that only the master made the halt status >>>> decision. Its trigger for testing the halt status was that the local >>>> static execution trace is longer than it was the last time that it >>>> tested the halt status. >>> >>> The key is that the system needs to be setup so that each of the 'slave' >>> H's would also generate that exact same answer if the outer copy (and >>> just that copy) is modified to not abort to allow the testing of it >>> being right in deciding to abort. >>> >> >> The inner and outer generate the exact same answer. The inner used to >> generate the answer and now the outer generates the same answer. If I >> don't force it to decide at a certain point then the inner one that >> reports that its input never halts is the one that has reached the >> deepest recursion depth and thus sees more of the execution trace before >> the other ones. > > So, you are admitting that the slave H WILL return the Non-Halting > answer in finite time and thus the H^ that called it was NOT in infinite > recursion and does itself Halt in finite time? > There is no H^. This is only the C/x86 code that has H1/H. > THAT is the implication that the slave H will behave exactly the same as > the master. > >> >>>> >>>>> This means that since the 'master' H(P,P) returns non-halting, that >>>>> must >>>>> be consistent with the copy of H inside P ALSO return the answer of >>>>> non-halting when given that exact same input. >>>>> >>>>> The 'assumption' that it will not return is a violation of that. >>>>> >>>>> Either H is using unsound logic, or H is not a computation because the >>>>> 'slave' H doesn't behave the same way. >>>>> >>>>>> >>>>>>> Presence of things like static local variables don't by themselves >>>>>>> invalidate you ability to be a Computation, but do mean you really do >>>>>>> need to show that it is one. >>>>>>> >>>>>> >>>>>> That is great. What are the requirements of a computation? >>>>>> >>>>>> given an input of the function domain it can return the corresponding >>>>>> output. https://en.wikipedia.org/wiki/Computable_function >>>>> >>>>> It is a bit more that a function with a specific value for a specific >>>>> input, as it also needs to be the results of an 'algorithm', a step by >>>>> step listing of instructions to get to the result. >>>>> >>>>> If all of the inputs to the algorithm are part of the formal input to >>>>> the function, then you get a computation. >>>>> >>>> >>>> Formal input is typically restricted to input parameters. >>>> The use of the static local execution_trace is to store intermediate >>>> results that are derived on the basis of the input parameters. >>> >>> Watch out, input parameters are for THAT INSTANCE, so a slave instance >>> can't act differently (as far as its caller can tell) just because it is >>> a slave instance. >> >> Yet in this case that is simply factually incorrect. The deeper that the >> recursive simulation goes the longer the execution trace becomes. As >> soon as the execution trace is long enough to match an infinitely >> repeating pattern simulation is aborted. >> >> Without a static local variable it is impossible for the halt decider to >> see that it has ever been invoked more than once. Without a static local >> variable every time that it is invoked its execution trace is emptied. > > Again, it isn't the fact that the static local variable exist that > causes the problem, but EVERY copy of the decider needs to act exactly > the same to its caller when provided the exact same inputs. > > So the slave Hs need to be able and considered to abort their own > simulations just like the master did, and thus reveal that the master > was in error in assuming they would not. > The way that it originally worked was that the first recursive simulation of H that saw P called H twice in a row was the one that aborted the simulation. >> >>> Remember each instance represents its own computation, >>> and that computation must generate that same answer for the same inputs. >>> >> >> That seems to mean that every function called in infinite recursion is >> not allowed to keep track that it was called in infinite recursion. > > No, it does not say that. Since every level of the decider WILL abort > its simulation in a finite amount of time, there NEVER WAS an infinite > recursion at any point. > This is the part that is over your head. It took me at least three days to understand this myself. Unless the first H that sees the infinite behavior aborts its simulation no H ever aborts its simulation. It it like being stuck in an infinite loop where you keep saying that you will mow the lawn tomorrow. When tomorrow arrives you will still mow the law tomorrow yet now tomorrow refers to a different day. If the halt decider aborts it simulation as soon as it sees two recursive invocations then we avoid this infinite loop. It is like today is Tueday and you say you will mow the lawn on Wednesday. When tomorrow comes it is Wednesday and the day to mow the lawn. > Only a finite number of machines were ever created and each of those, if > allowed to complete themselves (without affecting the code on their > tape) would complete in finite time. > > Every H[i] will simulate P[i+1] which calls H[i+1] which will start the > simulation of P[i+2] which triggers the aborting mechanism, so NO H[i] > ended up being infinity recursive, but only runs for a finite number of > steps and levels. > > H[i] makes the error in that it THINKS P[i+1] will be infinite because > H[i] doesn't take into account that H[i+1] WILL abort it simulation just > like H[i] is doing, and thus it WRONGLY THINKS that P is non-halting. > >> >>>> >>>>>> >>>>>>> So, as of now, the proposition that your code is eligible to be a >>>>>>> decider is unproven, and can not just be 'assumed' >>>>>>> >>>>>>> If we ever see a case where two copies of H given the same input act >>>>>>> differently, then this statement is proved in the negative. >>>>>>> >>>>>> >>>>>> >>>>> >>>> >>>> >>> >> >> > -- 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-18 16:55 -0400 |
| Subject | Re: Why do theory of computation problems require pure functions? [mow lawn] |
| Message-ID | <ens1J.87175$rl3.35644@fx45.iad> |
| In reply to | #39454 |
On 9/18/21 4:07 PM, olcott wrote: > On 9/18/2021 2:52 PM, Richard Damon wrote: >> On 9/18/21 3:30 PM, olcott wrote: >>> On 9/18/2021 2:08 PM, Richard Damon wrote: >>>> On 9/18/21 12:50 PM, olcott wrote: >>>>> On 9/18/2021 11:28 AM, Richard Damon wrote: >>>>>> On 9/18/21 12:15 PM, olcott wrote: >>>>>>> On 9/18/2021 10:52 AM, Richard Damon wrote: >>>>>>>> On 9/18/21 11:39 AM, olcott wrote: >>>>>>>>> On 9/18/2021 10:37 AM, Richard Damon wrote: >>>>>>>>>> On 9/18/21 11:29 AM, olcott wrote: >>>>>>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote: >>>>>>>>>>>> On 9/18/21 11:17 AM, olcott wrote: >>>>>>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>>>>>>> >>>>>>>>>>>>>>> I either must stick with C/x86 code or write a RASP >>>>>>>>>>>>>>> machine, the >>>>>>>>>>>>>>> only >>>>>>>>>>>>>>> way that my key insights can possible be fully understood >>>>>>>>>>>>>>> is to >>>>>>>>>>>>>>> have >>>>>>>>>>>>>>> every single detail as fully operational code such that >>>>>>>>>>>>>>> we can >>>>>>>>>>>>>>> simply >>>>>>>>>>>>>>> see what it does and thus not merely imagine what it >>>>>>>>>>>>>>> would do. >>>>>>>>>>>>>> >>>>>>>>>>>>>> Why do you insist on continuously repeating this rather >>>>>>>>>>>>>> ridiculous >>>>>>>>>>>>>> claim? >>>>>>>>>>>>>> >>>>>>>>>>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>>>>>>>>>> imagine >>>>>>>>>>>>>> what it would do.' One can see *exactly* what it does. >>>>>>>>>>>>>> >>>>>>>>>>>>>> André >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> When H is defined as a simulating halt decider then H >>>>>>>>>>>>> correctly >>>>>>>>>>>>> decides >>>>>>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>> >>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting when it >>>>>>>>>>>> actually >>>>>>>>>>>> Halts. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> Which says that it is deciding that H^(<H^>) is a non-halting >>>>>>>>>> computation, but if we run H^(<H^>) it ends up at its terminal >>>>>>>>>> state >>>>>>>>>> H^.qy which halts. (Since the code for H^ is derived from the >>>>>>>>>> code >>>>>>>>>> of H, >>>>>>>>>> and the state H^.qn is the corresponding state to H.qn) >>>>>>>>>> >>>>>>>>> >>>>>>>>> So does my use of a static local variable by itself make my >>>>>>>>> code not >>>>>>>>> apply to the halting problem or not? >>>>>>>>> >>>>>>>> >>>>>>>> No, but that doesn't mean that the presence of the static local >>>>>>>> variable >>>>>>>> is unconditionally allowed. >>>>>>>> >>>>>>>> You need to PROVE that your program is a Computation. >>>>>>>> >>>>>>>> Lack of things like static local variables make that proof much >>>>>>>> easier. >>>>>>>> as if all information inside the program can only be derived >>>>>>>> from the >>>>>>>> official input, then there is no source of 'illegal' information. >>>>>>>> >>>>>>> >>>>>>> The halt status decision is entirely based on the execution trace >>>>>>> derived from the input machine address pair. >>>>>> >>>>>> Right, but that ALSO applies to the simulated copies of H, which >>>>>> need to >>>>>> give the exact same answer given the exact same input. >>>>>> >>>>> >>>>> The original way that it worked was that the very first slave that saw >>>>> that an infinite behavior pattern was matched reported this through a >>>>> static variable that every master/slave instance of H used as their >>>>> while (**Aborted == 0) termination condition. >>>>> >>>>> Then I changed this so that only the master made the halt status >>>>> decision. Its trigger for testing the halt status was that the local >>>>> static execution trace is longer than it was the last time that it >>>>> tested the halt status. >>>> >>>> The key is that the system needs to be setup so that each of the >>>> 'slave' >>>> H's would also generate that exact same answer if the outer copy (and >>>> just that copy) is modified to not abort to allow the testing of it >>>> being right in deciding to abort. >>>> >>> >>> The inner and outer generate the exact same answer. The inner used to >>> generate the answer and now the outer generates the same answer. If I >>> don't force it to decide at a certain point then the inner one that >>> reports that its input never halts is the one that has reached the >>> deepest recursion depth and thus sees more of the execution trace before >>> the other ones. >> >> So, you are admitting that the slave H WILL return the Non-Halting >> answer in finite time and thus the H^ that called it was NOT in infinite >> recursion and does itself Halt in finite time? >> > > There is no H^. This is only the C/x86 code that has H1/H. If you have no code that matches the H^ in the Linz proof, then you aren't talking about it. You, for some strange reason, see to want to call this P. The fact that you don't seem to understand the ^ operator of Linz makes me wonder how much you actually understand what the proof is talking about. > >> THAT is the implication that the slave H will behave exactly the same as >> the master. >> >>> >>>>> >>>>>> This means that since the 'master' H(P,P) returns non-halting, that >>>>>> must >>>>>> be consistent with the copy of H inside P ALSO return the answer of >>>>>> non-halting when given that exact same input. >>>>>> >>>>>> The 'assumption' that it will not return is a violation of that. >>>>>> >>>>>> Either H is using unsound logic, or H is not a computation because >>>>>> the >>>>>> 'slave' H doesn't behave the same way. >>>>>> >>>>>>> >>>>>>>> Presence of things like static local variables don't by themselves >>>>>>>> invalidate you ability to be a Computation, but do mean you >>>>>>>> really do >>>>>>>> need to show that it is one. >>>>>>>> >>>>>>> >>>>>>> That is great. What are the requirements of a computation? >>>>>>> >>>>>>> given an input of the function domain it can return the >>>>>>> corresponding >>>>>>> output. https://en.wikipedia.org/wiki/Computable_function >>>>>> >>>>>> It is a bit more that a function with a specific value for a specific >>>>>> input, as it also needs to be the results of an 'algorithm', a >>>>>> step by >>>>>> step listing of instructions to get to the result. >>>>>> >>>>>> If all of the inputs to the algorithm are part of the formal input to >>>>>> the function, then you get a computation. >>>>>> >>>>> >>>>> Formal input is typically restricted to input parameters. >>>>> The use of the static local execution_trace is to store intermediate >>>>> results that are derived on the basis of the input parameters. >>>> >>>> Watch out, input parameters are for THAT INSTANCE, so a slave instance >>>> can't act differently (as far as its caller can tell) just because >>>> it is >>>> a slave instance. >>> >>> Yet in this case that is simply factually incorrect. The deeper that the >>> recursive simulation goes the longer the execution trace becomes. As >>> soon as the execution trace is long enough to match an infinitely >>> repeating pattern simulation is aborted. >>> >>> Without a static local variable it is impossible for the halt decider to >>> see that it has ever been invoked more than once. Without a static local >>> variable every time that it is invoked its execution trace is emptied. >> >> Again, it isn't the fact that the static local variable exist that >> causes the problem, but EVERY copy of the decider needs to act exactly >> the same to its caller when provided the exact same inputs. >> >> So the slave Hs need to be able and considered to abort their own >> simulations just like the master did, and thus reveal that the master >> was in error in assuming they would not. >> > > The way that it originally worked was that the first recursive > simulation of H that saw P called H twice in a row was the one that > aborted the simulation. 'Aborting the simulation' as in aborting the whole operation makes H not a proper halt decider, unless H^ was built as a seperate program that exec'ed the decider to get the answer, but I don't think your simulator can handle that case. You NEED for the outer H to return the answer. > >>> >>>> Remember each instance represents its own computation, >>>> and that computation must generate that same answer for the same >>>> inputs. >>>> >>> >>> That seems to mean that every function called in infinite recursion is >>> not allowed to keep track that it was called in infinite recursion. >> >> No, it does not say that. Since every level of the decider WILL abort >> its simulation in a finite amount of time, there NEVER WAS an infinite >> recursion at any point. >> > > This is the part that is over your head. > It took me at least three days to understand this myself. > > Unless the first H that sees the infinite behavior aborts its simulation > no H ever aborts its simulation. WRONG. Your are doing your logic backwards. The algorithm for H has to be determined FIRST. Once this is established then either H WILL abort H^(H^) or H will not abort H^*H^). If H doesn't abort H^(H^) then H will never answer the question H(H^,H^) If H does abort H^(H^) then there is NO infinite behavior in the system at all, BECAUSE H will abort it in finite time and H needs to take that behavior of the copies of H it is simulating into account. Anytime you use logic postulating over different version of H, you are likely doing it wrong. > > It it like being stuck in an infinite loop where you keep saying that > you will mow the lawn tomorrow. When tomorrow arrives you will still mow > the law tomorrow yet now tomorrow refers to a different day. Right, but that isn't the case here. STRAWMAN. EVERY H will abort its simulation after a finite amount of work, and wrongly say that its input will never halt, so EVERY H does its job and every H^ is finite, even if H thinks it will not get it done. No H 'puts off for tomorrow' (or if you do have an H that put off for tomorrow, that is the case of the H that doesn't ever answer) > > If the halt decider aborts it simulation as soon as it sees two > recursive invocations then we avoid this infinite loop. And if it is programmed to detect that case, there WAS NO infinite loop in the first place, as EVERY copy of H will do that, including the one in the H^ that is being simulated, so that H^ will not run forever. > > It is like today is Tueday and you say you will mow the lawn on > Wednesday. When tomorrow comes it is Wednesday and the day to mow the lawn. EVERY H aborts its simulation after finite time and says its input is non-halting so EVERY H^ halts in finite time and every H was wrong. Every H mows the lawn TODAY, after thinking that the H it is simulating won't get to it, so the lawn is mowed every day. > >> Only a finite number of machines were ever created and each of those, if >> allowed to complete themselves (without affecting the code on their >> tape) would complete in finite time. >> >> Every H[i] will simulate P[i+1] which calls H[i+1] which will start the >> simulation of P[i+2] which triggers the aborting mechanism, so NO H[i] >> ended up being infinity recursive, but only runs for a finite number of >> steps and levels. >> >> H[i] makes the error in that it THINKS P[i+1] will be infinite because >> H[i] doesn't take into account that H[i+1] WILL abort it simulation just >> like H[i] is doing, and thus it WRONGLY THINKS that P is non-halting. >> >>> >>>>> >>>>>>> >>>>>>>> So, as of now, the proposition that your code is eligible to be a >>>>>>>> decider is unproven, and can not just be 'assumed' >>>>>>>> >>>>>>>> If we ever see a case where two copies of H given the same input >>>>>>>> act >>>>>>>> differently, then this statement is proved in the negative. >>>>>>>> >>>>>>> >>>>>>> >>>>>> >>>>> >>>>> >>>> >>> >>> >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-18 16:22 -0500 |
| Subject | Re: Why do theory of computation problems require pure functions? [mow lawn] |
| Message-ID | <--qdna3Vx6MUxdv8nZ2dnUU7-SnNnZ2d@giganews.com> |
| In reply to | #39460 |
On 9/18/2021 3:55 PM, Richard Damon wrote: > On 9/18/21 4:07 PM, olcott wrote: >> On 9/18/2021 2:52 PM, Richard Damon wrote: >>> On 9/18/21 3:30 PM, olcott wrote: >>>> On 9/18/2021 2:08 PM, Richard Damon wrote: >>>>> On 9/18/21 12:50 PM, olcott wrote: >>>>>> On 9/18/2021 11:28 AM, Richard Damon wrote: >>>>>>> On 9/18/21 12:15 PM, olcott wrote: >>>>>>>> On 9/18/2021 10:52 AM, Richard Damon wrote: >>>>>>>>> On 9/18/21 11:39 AM, olcott wrote: >>>>>>>>>> On 9/18/2021 10:37 AM, Richard Damon wrote: >>>>>>>>>>> On 9/18/21 11:29 AM, olcott wrote: >>>>>>>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote: >>>>>>>>>>>>> On 9/18/21 11:17 AM, olcott wrote: >>>>>>>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> I either must stick with C/x86 code or write a RASP >>>>>>>>>>>>>>>> machine, the >>>>>>>>>>>>>>>> only >>>>>>>>>>>>>>>> way that my key insights can possible be fully understood >>>>>>>>>>>>>>>> is to >>>>>>>>>>>>>>>> have >>>>>>>>>>>>>>>> every single detail as fully operational code such that >>>>>>>>>>>>>>>> we can >>>>>>>>>>>>>>>> simply >>>>>>>>>>>>>>>> see what it does and thus not merely imagine what it >>>>>>>>>>>>>>>> would do. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Why do you insist on continuously repeating this rather >>>>>>>>>>>>>>> ridiculous >>>>>>>>>>>>>>> claim? >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>>>>>>>>>>> imagine >>>>>>>>>>>>>>> what it would do.' One can see *exactly* what it does. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> André >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> When H is defined as a simulating halt decider then H >>>>>>>>>>>>>> correctly >>>>>>>>>>>>>> decides >>>>>>>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>> >>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting when it >>>>>>>>>>>>> actually >>>>>>>>>>>>> Halts. >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> Which says that it is deciding that H^(<H^>) is a non-halting >>>>>>>>>>> computation, but if we run H^(<H^>) it ends up at its terminal >>>>>>>>>>> state >>>>>>>>>>> H^.qy which halts. (Since the code for H^ is derived from the >>>>>>>>>>> code >>>>>>>>>>> of H, >>>>>>>>>>> and the state H^.qn is the corresponding state to H.qn) >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> So does my use of a static local variable by itself make my >>>>>>>>>> code not >>>>>>>>>> apply to the halting problem or not? >>>>>>>>>> >>>>>>>>> >>>>>>>>> No, but that doesn't mean that the presence of the static local >>>>>>>>> variable >>>>>>>>> is unconditionally allowed. >>>>>>>>> >>>>>>>>> You need to PROVE that your program is a Computation. >>>>>>>>> >>>>>>>>> Lack of things like static local variables make that proof much >>>>>>>>> easier. >>>>>>>>> as if all information inside the program can only be derived >>>>>>>>> from the >>>>>>>>> official input, then there is no source of 'illegal' information. >>>>>>>>> >>>>>>>> >>>>>>>> The halt status decision is entirely based on the execution trace >>>>>>>> derived from the input machine address pair. >>>>>>> >>>>>>> Right, but that ALSO applies to the simulated copies of H, which >>>>>>> need to >>>>>>> give the exact same answer given the exact same input. >>>>>>> >>>>>> >>>>>> The original way that it worked was that the very first slave that saw >>>>>> that an infinite behavior pattern was matched reported this through a >>>>>> static variable that every master/slave instance of H used as their >>>>>> while (**Aborted == 0) termination condition. >>>>>> >>>>>> Then I changed this so that only the master made the halt status >>>>>> decision. Its trigger for testing the halt status was that the local >>>>>> static execution trace is longer than it was the last time that it >>>>>> tested the halt status. >>>>> >>>>> The key is that the system needs to be setup so that each of the >>>>> 'slave' >>>>> H's would also generate that exact same answer if the outer copy (and >>>>> just that copy) is modified to not abort to allow the testing of it >>>>> being right in deciding to abort. >>>>> >>>> >>>> The inner and outer generate the exact same answer. The inner used to >>>> generate the answer and now the outer generates the same answer. If I >>>> don't force it to decide at a certain point then the inner one that >>>> reports that its input never halts is the one that has reached the >>>> deepest recursion depth and thus sees more of the execution trace before >>>> the other ones. >>> >>> So, you are admitting that the slave H WILL return the Non-Halting >>> answer in finite time and thus the H^ that called it was NOT in infinite >>> recursion and does itself Halt in finite time? >>> >> >> There is no H^. This is only the C/x86 code that has H1/H. > > If you have no code that matches the H^ in the Linz proof, then you > aren't talking about it. > > You, for some strange reason, see to want to call this P. > > The fact that you don't seem to understand the ^ operator of Linz makes > me wonder how much you actually understand what the proof is talking about. > > >> >>> THAT is the implication that the slave H will behave exactly the same as >>> the master. >>> >>>> >>>>>> >>>>>>> This means that since the 'master' H(P,P) returns non-halting, that >>>>>>> must >>>>>>> be consistent with the copy of H inside P ALSO return the answer of >>>>>>> non-halting when given that exact same input. >>>>>>> >>>>>>> The 'assumption' that it will not return is a violation of that. >>>>>>> >>>>>>> Either H is using unsound logic, or H is not a computation because >>>>>>> the >>>>>>> 'slave' H doesn't behave the same way. >>>>>>> >>>>>>>> >>>>>>>>> Presence of things like static local variables don't by themselves >>>>>>>>> invalidate you ability to be a Computation, but do mean you >>>>>>>>> really do >>>>>>>>> need to show that it is one. >>>>>>>>> >>>>>>>> >>>>>>>> That is great. What are the requirements of a computation? >>>>>>>> >>>>>>>> given an input of the function domain it can return the >>>>>>>> corresponding >>>>>>>> output. https://en.wikipedia.org/wiki/Computable_function >>>>>>> >>>>>>> It is a bit more that a function with a specific value for a specific >>>>>>> input, as it also needs to be the results of an 'algorithm', a >>>>>>> step by >>>>>>> step listing of instructions to get to the result. >>>>>>> >>>>>>> If all of the inputs to the algorithm are part of the formal input to >>>>>>> the function, then you get a computation. >>>>>>> >>>>>> >>>>>> Formal input is typically restricted to input parameters. >>>>>> The use of the static local execution_trace is to store intermediate >>>>>> results that are derived on the basis of the input parameters. >>>>> >>>>> Watch out, input parameters are for THAT INSTANCE, so a slave instance >>>>> can't act differently (as far as its caller can tell) just because >>>>> it is >>>>> a slave instance. >>>> >>>> Yet in this case that is simply factually incorrect. The deeper that the >>>> recursive simulation goes the longer the execution trace becomes. As >>>> soon as the execution trace is long enough to match an infinitely >>>> repeating pattern simulation is aborted. >>>> >>>> Without a static local variable it is impossible for the halt decider to >>>> see that it has ever been invoked more than once. Without a static local >>>> variable every time that it is invoked its execution trace is emptied. >>> >>> Again, it isn't the fact that the static local variable exist that >>> causes the problem, but EVERY copy of the decider needs to act exactly >>> the same to its caller when provided the exact same inputs. >>> >>> So the slave Hs need to be able and considered to abort their own >>> simulations just like the master did, and thus reveal that the master >>> was in error in assuming they would not. >>> >> >> The way that it originally worked was that the first recursive >> simulation of H that saw P called H twice in a row was the one that >> aborted the simulation. > > > 'Aborting the simulation' as in aborting the whole operation makes H not > a proper halt decider, unless H^ was built as a seperate program that > exec'ed the decider to get the answer, but I don't think your simulator > can handle that case. > > You NEED for the outer H to return the answer. That is why I changed it so that it does it that way now. > >> >>>> >>>>> Remember each instance represents its own computation, >>>>> and that computation must generate that same answer for the same >>>>> inputs. >>>>> >>>> >>>> That seems to mean that every function called in infinite recursion is >>>> not allowed to keep track that it was called in infinite recursion. >>> >>> No, it does not say that. Since every level of the decider WILL abort >>> its simulation in a finite amount of time, there NEVER WAS an infinite >>> recursion at any point. >>> >> >> This is the part that is over your head. >> It took me at least three days to understand this myself. >> >> Unless the first H that sees the infinite behavior aborts its simulation >> no H ever aborts its simulation. > > > WRONG. Your are doing your logic backwards. > > The algorithm for H has to be determined FIRST. > > Once this is established then either H WILL abort H^(H^) or H will not > abort H^*H^). > > If H doesn't abort H^(H^) then H will never answer the question H(H^,H^) > > If H does abort H^(H^) then there is NO infinite behavior in the system > at all, BECAUSE H will abort it in finite time and H needs to take that > behavior of the copies of H it is simulating into account. > There is Olcott H1/H/P and Linz H/Ĥ Whenever I am talking about Ĥ I am only taling about Linz. > Anytime you use logic postulating over different version of H, you are > likely doing it wrong. > >> >> It it like being stuck in an infinite loop where you keep saying that >> you will mow the lawn tomorrow. When tomorrow arrives you will still mow >> the law tomorrow yet now tomorrow refers to a different day. > > > Right, but that isn't the case here. STRAWMAN. > > EVERY H will abort its simulation after a finite amount of work, and No H ever aborts any simulation of its input unless this input is aborted at a fixed number of recursive simulations. I set this limit at the smallest number of 2. If H keeps waiting for the next H to abort the simulation of its input that it like you saying that you will mow the lawn tomorrow every single day. On Tuesday you say tommorow, then on Wednesday you say tomorrow... When I say exact two iterations on Tuesday I am saying that the lawn will be mowed on Wednesday. As soon as Wednesday gets here (exactly two recursive simulations) it is now time to mow the lawn (abort the input). > wrongly say that its input will never halt, so EVERY H does its job and > every H^ is finite, even if H thinks it will not get it done. > > No H 'puts off for tomorrow' (or if you do have an H that put off for > tomorrow, that is the case of the H that doesn't ever answer) > >> >> If the halt decider aborts it simulation as soon as it sees two >> recursive invocations then we avoid this infinite loop. > > And if it is programmed to detect that case, there WAS NO infinite loop > in the first place, as EVERY copy of H will do that, including the one > in the H^ that is being simulated, so that H^ will not run forever. > >> >> It is like today is Tueday and you say you will mow the lawn on >> Wednesday. When tomorrow comes it is Wednesday and the day to mow the lawn. > > EVERY H aborts its simulation after finite time and says its input is > non-halting so EVERY H^ halts in finite time and every H was wrong. > > Every H mows the lawn TODAY, after thinking that the H it is simulating > won't get to it, so the lawn is mowed every day. > >> >>> Only a finite number of machines were ever created and each of those, if >>> allowed to complete themselves (without affecting the code on their >>> tape) would complete in finite time. >>> >>> Every H[i] will simulate P[i+1] which calls H[i+1] which will start the >>> simulation of P[i+2] which triggers the aborting mechanism, so NO H[i] >>> ended up being infinity recursive, but only runs for a finite number of >>> steps and levels. >>> >>> H[i] makes the error in that it THINKS P[i+1] will be infinite because >>> H[i] doesn't take into account that H[i+1] WILL abort it simulation just >>> like H[i] is doing, and thus it WRONGLY THINKS that P is non-halting. >>> >>>> >>>>>> >>>>>>>> >>>>>>>>> So, as of now, the proposition that your code is eligible to be a >>>>>>>>> decider is unproven, and can not just be 'assumed' >>>>>>>>> >>>>>>>>> If we ever see a case where two copies of H given the same input >>>>>>>>> act >>>>>>>>> differently, then this statement is proved in the negative. >>>>>>>>> >>>>>>>> >>>>>>>> >>>>>>> >>>>>> >>>>>> >>>>> >>>> >>>> >>> >> >> > -- 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-18 17:38 -0400 |
| Subject | Re: Why do theory of computation problems require pure functions? [mow lawn] |
| Message-ID | <D%s1J.27795$6u6.6307@fx03.iad> |
| In reply to | #39468 |
On 9/18/21 5:22 PM, olcott wrote: > On 9/18/2021 3:55 PM, Richard Damon wrote: >> On 9/18/21 4:07 PM, olcott wrote: >>> On 9/18/2021 2:52 PM, Richard Damon wrote: >>>> On 9/18/21 3:30 PM, olcott wrote: >>>>> On 9/18/2021 2:08 PM, Richard Damon wrote: >>>>>> On 9/18/21 12:50 PM, olcott wrote: >>>>>>> On 9/18/2021 11:28 AM, Richard Damon wrote: >>>>>>>> On 9/18/21 12:15 PM, olcott wrote: >>>>>>>>> On 9/18/2021 10:52 AM, Richard Damon wrote: >>>>>>>>>> On 9/18/21 11:39 AM, olcott wrote: >>>>>>>>>>> On 9/18/2021 10:37 AM, Richard Damon wrote: >>>>>>>>>>>> On 9/18/21 11:29 AM, olcott wrote: >>>>>>>>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote: >>>>>>>>>>>>>> On 9/18/21 11:17 AM, olcott wrote: >>>>>>>>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> I either must stick with C/x86 code or write a RASP >>>>>>>>>>>>>>>>> machine, the >>>>>>>>>>>>>>>>> only >>>>>>>>>>>>>>>>> way that my key insights can possible be fully understood >>>>>>>>>>>>>>>>> is to >>>>>>>>>>>>>>>>> have >>>>>>>>>>>>>>>>> every single detail as fully operational code such that >>>>>>>>>>>>>>>>> we can >>>>>>>>>>>>>>>>> simply >>>>>>>>>>>>>>>>> see what it does and thus not merely imagine what it >>>>>>>>>>>>>>>>> would do. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Why do you insist on continuously repeating this rather >>>>>>>>>>>>>>>> ridiculous >>>>>>>>>>>>>>>> claim? >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> When working with Turing Machines one doesn't need to >>>>>>>>>>>>>>>> 'merely >>>>>>>>>>>>>>>> imagine >>>>>>>>>>>>>>>> what it would do.' One can see *exactly* what it does. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> André >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> When H is defined as a simulating halt decider then H >>>>>>>>>>>>>>> correctly >>>>>>>>>>>>>>> decides >>>>>>>>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting >>>>>>>>>>>>>> when it >>>>>>>>>>>>>> actually >>>>>>>>>>>>>> Halts. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> Which says that it is deciding that H^(<H^>) is a non-halting >>>>>>>>>>>> computation, but if we run H^(<H^>) it ends up at its terminal >>>>>>>>>>>> state >>>>>>>>>>>> H^.qy which halts. (Since the code for H^ is derived from the >>>>>>>>>>>> code >>>>>>>>>>>> of H, >>>>>>>>>>>> and the state H^.qn is the corresponding state to H.qn) >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> So does my use of a static local variable by itself make my >>>>>>>>>>> code not >>>>>>>>>>> apply to the halting problem or not? >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> No, but that doesn't mean that the presence of the static local >>>>>>>>>> variable >>>>>>>>>> is unconditionally allowed. >>>>>>>>>> >>>>>>>>>> You need to PROVE that your program is a Computation. >>>>>>>>>> >>>>>>>>>> Lack of things like static local variables make that proof much >>>>>>>>>> easier. >>>>>>>>>> as if all information inside the program can only be derived >>>>>>>>>> from the >>>>>>>>>> official input, then there is no source of 'illegal' information. >>>>>>>>>> >>>>>>>>> >>>>>>>>> The halt status decision is entirely based on the execution trace >>>>>>>>> derived from the input machine address pair. >>>>>>>> >>>>>>>> Right, but that ALSO applies to the simulated copies of H, which >>>>>>>> need to >>>>>>>> give the exact same answer given the exact same input. >>>>>>>> >>>>>>> >>>>>>> The original way that it worked was that the very first slave >>>>>>> that saw >>>>>>> that an infinite behavior pattern was matched reported this >>>>>>> through a >>>>>>> static variable that every master/slave instance of H used as their >>>>>>> while (**Aborted == 0) termination condition. >>>>>>> >>>>>>> Then I changed this so that only the master made the halt status >>>>>>> decision. Its trigger for testing the halt status was that the local >>>>>>> static execution trace is longer than it was the last time that it >>>>>>> tested the halt status. >>>>>> >>>>>> The key is that the system needs to be setup so that each of the >>>>>> 'slave' >>>>>> H's would also generate that exact same answer if the outer copy (and >>>>>> just that copy) is modified to not abort to allow the testing of it >>>>>> being right in deciding to abort. >>>>>> >>>>> >>>>> The inner and outer generate the exact same answer. The inner used to >>>>> generate the answer and now the outer generates the same answer. If I >>>>> don't force it to decide at a certain point then the inner one that >>>>> reports that its input never halts is the one that has reached the >>>>> deepest recursion depth and thus sees more of the execution trace >>>>> before >>>>> the other ones. >>>> >>>> So, you are admitting that the slave H WILL return the Non-Halting >>>> answer in finite time and thus the H^ that called it was NOT in >>>> infinite >>>> recursion and does itself Halt in finite time? >>>> >>> >>> There is no H^. This is only the C/x86 code that has H1/H. >> >> If you have no code that matches the H^ in the Linz proof, then you >> aren't talking about it. >> >> You, for some strange reason, see to want to call this P. >> >> The fact that you don't seem to understand the ^ operator of Linz makes >> me wonder how much you actually understand what the proof is talking >> about. >> >> >>> >>>> THAT is the implication that the slave H will behave exactly the >>>> same as >>>> the master. >>>> >>>>> >>>>>>> >>>>>>>> This means that since the 'master' H(P,P) returns non-halting, that >>>>>>>> must >>>>>>>> be consistent with the copy of H inside P ALSO return the answer of >>>>>>>> non-halting when given that exact same input. >>>>>>>> >>>>>>>> The 'assumption' that it will not return is a violation of that. >>>>>>>> >>>>>>>> Either H is using unsound logic, or H is not a computation because >>>>>>>> the >>>>>>>> 'slave' H doesn't behave the same way. >>>>>>>> >>>>>>>>> >>>>>>>>>> Presence of things like static local variables don't by >>>>>>>>>> themselves >>>>>>>>>> invalidate you ability to be a Computation, but do mean you >>>>>>>>>> really do >>>>>>>>>> need to show that it is one. >>>>>>>>>> >>>>>>>>> >>>>>>>>> That is great. What are the requirements of a computation? >>>>>>>>> >>>>>>>>> given an input of the function domain it can return the >>>>>>>>> corresponding >>>>>>>>> output. https://en.wikipedia.org/wiki/Computable_function >>>>>>>> >>>>>>>> It is a bit more that a function with a specific value for a >>>>>>>> specific >>>>>>>> input, as it also needs to be the results of an 'algorithm', a >>>>>>>> step by >>>>>>>> step listing of instructions to get to the result. >>>>>>>> >>>>>>>> If all of the inputs to the algorithm are part of the formal >>>>>>>> input to >>>>>>>> the function, then you get a computation. >>>>>>>> >>>>>>> >>>>>>> Formal input is typically restricted to input parameters. >>>>>>> The use of the static local execution_trace is to store intermediate >>>>>>> results that are derived on the basis of the input parameters. >>>>>> >>>>>> Watch out, input parameters are for THAT INSTANCE, so a slave >>>>>> instance >>>>>> can't act differently (as far as its caller can tell) just because >>>>>> it is >>>>>> a slave instance. >>>>> >>>>> Yet in this case that is simply factually incorrect. The deeper >>>>> that the >>>>> recursive simulation goes the longer the execution trace becomes. As >>>>> soon as the execution trace is long enough to match an infinitely >>>>> repeating pattern simulation is aborted. >>>>> >>>>> Without a static local variable it is impossible for the halt >>>>> decider to >>>>> see that it has ever been invoked more than once. Without a static >>>>> local >>>>> variable every time that it is invoked its execution trace is emptied. >>>> >>>> Again, it isn't the fact that the static local variable exist that >>>> causes the problem, but EVERY copy of the decider needs to act exactly >>>> the same to its caller when provided the exact same inputs. >>>> >>>> So the slave Hs need to be able and considered to abort their own >>>> simulations just like the master did, and thus reveal that the master >>>> was in error in assuming they would not. >>>> >>> >>> The way that it originally worked was that the first recursive >>> simulation of H that saw P called H twice in a row was the one that >>> aborted the simulation. >> >> >> 'Aborting the simulation' as in aborting the whole operation makes H not >> a proper halt decider, unless H^ was built as a seperate program that >> exec'ed the decider to get the answer, but I don't think your simulator >> can handle that case. >> >> You NEED for the outer H to return the answer. > > That is why I changed it so that it does it that way now. > >> >>> >>>>> >>>>>> Remember each instance represents its own computation, >>>>>> and that computation must generate that same answer for the same >>>>>> inputs. >>>>>> >>>>> >>>>> That seems to mean that every function called in infinite recursion is >>>>> not allowed to keep track that it was called in infinite recursion. >>>> >>>> No, it does not say that. Since every level of the decider WILL abort >>>> its simulation in a finite amount of time, there NEVER WAS an infinite >>>> recursion at any point. >>>> >>> >>> This is the part that is over your head. >>> It took me at least three days to understand this myself. >>> >>> Unless the first H that sees the infinite behavior aborts its simulation >>> no H ever aborts its simulation. >> >> >> WRONG. Your are doing your logic backwards. >> >> The algorithm for H has to be determined FIRST. >> >> Once this is established then either H WILL abort H^(H^) or H will not >> abort H^*H^). >> >> If H doesn't abort H^(H^) then H will never answer the question H(H^,H^) >> >> If H does abort H^(H^) then there is NO infinite behavior in the system >> at all, BECAUSE H will abort it in finite time and H needs to take that >> behavior of the copies of H it is simulating into account. >> > > There is Olcott H1/H/P and Linz H/Ĥ > Whenever I am talking about Ĥ I am only taling about Linz. And your H1/H show that either H1/H are two different computations, and thus H1 is NOT the H that disprove Linz, or H1/H isn't actually a computation and thus doesn't disprove Linz. FAIL. > >> Anytime you use logic postulating over different version of H, you are >> likely doing it wrong. >> >>> >>> It it like being stuck in an infinite loop where you keep saying that >>> you will mow the lawn tomorrow. When tomorrow arrives you will still mow >>> the law tomorrow yet now tomorrow refers to a different day. >> >> >> Right, but that isn't the case here. STRAWMAN. >> >> EVERY H will abort its simulation after a finite amount of work, and > > No H ever aborts any simulation of its input unless this input is > aborted at a fixed number of recursive simulations. I set this limit at > the smallest number of 2. You need to define what you H does. PERIOD. This 'No H' is just proving the point If H doesn't abort, then H doesn't answer and fails. If H does abort, H^/P Halts and H is wrong. It doesn't matter WHY H^/P Halts, just that it does. FAIL > > If H keeps waiting for the next H to abort the simulation of its input > that it like you saying that you will mow the lawn tomorrow every single > day. Yes, and that version of H never answers, so it is wrong. > > On Tuesday you say tommorow, then on Wednesday you say tomorrow... > > When I say exact two iterations on Tuesday I am saying that the lawn > will be mowed on Wednesday. As soon as Wednesday gets here (exactly two > recursive simulations) it is now time to mow the lawn (abort the input). > > And for the H that does abort, there never was an infinite execution so H^/P is halting. Again, it doesn't matter WHY H^/P end up halting, the fact that it does means that it is halting. The trace pattern that H calls as the proof of non-halting behavior is identical to the piece of the trace of H^/P that halted, thus calling it proof of non-halting is incorrect.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-18 16:48 -0500 |
| Subject | Re: Why do theory of computation problems require pure functions? [mow lawn] |
| Message-ID | <55edndY_zpAuw9v8nZ2dnUU7-eXNnZ2d@giganews.com> |
| In reply to | #39470 |
On 9/18/2021 4:38 PM, Richard Damon wrote: > On 9/18/21 5:22 PM, olcott wrote: >> On 9/18/2021 3:55 PM, Richard Damon wrote: >>> On 9/18/21 4:07 PM, olcott wrote: >>>> On 9/18/2021 2:52 PM, Richard Damon wrote: >>>>> On 9/18/21 3:30 PM, olcott wrote: >>>>>> On 9/18/2021 2:08 PM, Richard Damon wrote: >>>>>>> On 9/18/21 12:50 PM, olcott wrote: >>>>>>>> On 9/18/2021 11:28 AM, Richard Damon wrote: >>>>>>>>> On 9/18/21 12:15 PM, olcott wrote: >>>>>>>>>> On 9/18/2021 10:52 AM, Richard Damon wrote: >>>>>>>>>>> On 9/18/21 11:39 AM, olcott wrote: >>>>>>>>>>>> On 9/18/2021 10:37 AM, Richard Damon wrote: >>>>>>>>>>>>> On 9/18/21 11:29 AM, olcott wrote: >>>>>>>>>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote: >>>>>>>>>>>>>>> On 9/18/21 11:17 AM, olcott wrote: >>>>>>>>>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>>>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> I either must stick with C/x86 code or write a RASP >>>>>>>>>>>>>>>>>> machine, the >>>>>>>>>>>>>>>>>> only >>>>>>>>>>>>>>>>>> way that my key insights can possible be fully understood >>>>>>>>>>>>>>>>>> is to >>>>>>>>>>>>>>>>>> have >>>>>>>>>>>>>>>>>> every single detail as fully operational code such that >>>>>>>>>>>>>>>>>> we can >>>>>>>>>>>>>>>>>> simply >>>>>>>>>>>>>>>>>> see what it does and thus not merely imagine what it >>>>>>>>>>>>>>>>>> would do. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> Why do you insist on continuously repeating this rather >>>>>>>>>>>>>>>>> ridiculous >>>>>>>>>>>>>>>>> claim? >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> When working with Turing Machines one doesn't need to >>>>>>>>>>>>>>>>> 'merely >>>>>>>>>>>>>>>>> imagine >>>>>>>>>>>>>>>>> what it would do.' One can see *exactly* what it does. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> André >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> When H is defined as a simulating halt decider then H >>>>>>>>>>>>>>>> correctly >>>>>>>>>>>>>>>> decides >>>>>>>>>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting >>>>>>>>>>>>>>> when it >>>>>>>>>>>>>>> actually >>>>>>>>>>>>>>> Halts. >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> Which says that it is deciding that H^(<H^>) is a non-halting >>>>>>>>>>>>> computation, but if we run H^(<H^>) it ends up at its terminal >>>>>>>>>>>>> state >>>>>>>>>>>>> H^.qy which halts. (Since the code for H^ is derived from the >>>>>>>>>>>>> code >>>>>>>>>>>>> of H, >>>>>>>>>>>>> and the state H^.qn is the corresponding state to H.qn) >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> So does my use of a static local variable by itself make my >>>>>>>>>>>> code not >>>>>>>>>>>> apply to the halting problem or not? >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> No, but that doesn't mean that the presence of the static local >>>>>>>>>>> variable >>>>>>>>>>> is unconditionally allowed. >>>>>>>>>>> >>>>>>>>>>> You need to PROVE that your program is a Computation. >>>>>>>>>>> >>>>>>>>>>> Lack of things like static local variables make that proof much >>>>>>>>>>> easier. >>>>>>>>>>> as if all information inside the program can only be derived >>>>>>>>>>> from the >>>>>>>>>>> official input, then there is no source of 'illegal' information. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> The halt status decision is entirely based on the execution trace >>>>>>>>>> derived from the input machine address pair. >>>>>>>>> >>>>>>>>> Right, but that ALSO applies to the simulated copies of H, which >>>>>>>>> need to >>>>>>>>> give the exact same answer given the exact same input. >>>>>>>>> >>>>>>>> >>>>>>>> The original way that it worked was that the very first slave >>>>>>>> that saw >>>>>>>> that an infinite behavior pattern was matched reported this >>>>>>>> through a >>>>>>>> static variable that every master/slave instance of H used as their >>>>>>>> while (**Aborted == 0) termination condition. >>>>>>>> >>>>>>>> Then I changed this so that only the master made the halt status >>>>>>>> decision. Its trigger for testing the halt status was that the local >>>>>>>> static execution trace is longer than it was the last time that it >>>>>>>> tested the halt status. >>>>>>> >>>>>>> The key is that the system needs to be setup so that each of the >>>>>>> 'slave' >>>>>>> H's would also generate that exact same answer if the outer copy (and >>>>>>> just that copy) is modified to not abort to allow the testing of it >>>>>>> being right in deciding to abort. >>>>>>> >>>>>> >>>>>> The inner and outer generate the exact same answer. The inner used to >>>>>> generate the answer and now the outer generates the same answer. If I >>>>>> don't force it to decide at a certain point then the inner one that >>>>>> reports that its input never halts is the one that has reached the >>>>>> deepest recursion depth and thus sees more of the execution trace >>>>>> before >>>>>> the other ones. >>>>> >>>>> So, you are admitting that the slave H WILL return the Non-Halting >>>>> answer in finite time and thus the H^ that called it was NOT in >>>>> infinite >>>>> recursion and does itself Halt in finite time? >>>>> >>>> >>>> There is no H^. This is only the C/x86 code that has H1/H. >>> >>> If you have no code that matches the H^ in the Linz proof, then you >>> aren't talking about it. >>> >>> You, for some strange reason, see to want to call this P. >>> >>> The fact that you don't seem to understand the ^ operator of Linz makes >>> me wonder how much you actually understand what the proof is talking >>> about. >>> >>> >>>> >>>>> THAT is the implication that the slave H will behave exactly the >>>>> same as >>>>> the master. >>>>> >>>>>> >>>>>>>> >>>>>>>>> This means that since the 'master' H(P,P) returns non-halting, that >>>>>>>>> must >>>>>>>>> be consistent with the copy of H inside P ALSO return the answer of >>>>>>>>> non-halting when given that exact same input. >>>>>>>>> >>>>>>>>> The 'assumption' that it will not return is a violation of that. >>>>>>>>> >>>>>>>>> Either H is using unsound logic, or H is not a computation because >>>>>>>>> the >>>>>>>>> 'slave' H doesn't behave the same way. >>>>>>>>> >>>>>>>>>> >>>>>>>>>>> Presence of things like static local variables don't by >>>>>>>>>>> themselves >>>>>>>>>>> invalidate you ability to be a Computation, but do mean you >>>>>>>>>>> really do >>>>>>>>>>> need to show that it is one. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> That is great. What are the requirements of a computation? >>>>>>>>>> >>>>>>>>>> given an input of the function domain it can return the >>>>>>>>>> corresponding >>>>>>>>>> output. https://en.wikipedia.org/wiki/Computable_function >>>>>>>>> >>>>>>>>> It is a bit more that a function with a specific value for a >>>>>>>>> specific >>>>>>>>> input, as it also needs to be the results of an 'algorithm', a >>>>>>>>> step by >>>>>>>>> step listing of instructions to get to the result. >>>>>>>>> >>>>>>>>> If all of the inputs to the algorithm are part of the formal >>>>>>>>> input to >>>>>>>>> the function, then you get a computation. >>>>>>>>> >>>>>>>> >>>>>>>> Formal input is typically restricted to input parameters. >>>>>>>> The use of the static local execution_trace is to store intermediate >>>>>>>> results that are derived on the basis of the input parameters. >>>>>>> >>>>>>> Watch out, input parameters are for THAT INSTANCE, so a slave >>>>>>> instance >>>>>>> can't act differently (as far as its caller can tell) just because >>>>>>> it is >>>>>>> a slave instance. >>>>>> >>>>>> Yet in this case that is simply factually incorrect. The deeper >>>>>> that the >>>>>> recursive simulation goes the longer the execution trace becomes. As >>>>>> soon as the execution trace is long enough to match an infinitely >>>>>> repeating pattern simulation is aborted. >>>>>> >>>>>> Without a static local variable it is impossible for the halt >>>>>> decider to >>>>>> see that it has ever been invoked more than once. Without a static >>>>>> local >>>>>> variable every time that it is invoked its execution trace is emptied. >>>>> >>>>> Again, it isn't the fact that the static local variable exist that >>>>> causes the problem, but EVERY copy of the decider needs to act exactly >>>>> the same to its caller when provided the exact same inputs. >>>>> >>>>> So the slave Hs need to be able and considered to abort their own >>>>> simulations just like the master did, and thus reveal that the master >>>>> was in error in assuming they would not. >>>>> >>>> >>>> The way that it originally worked was that the first recursive >>>> simulation of H that saw P called H twice in a row was the one that >>>> aborted the simulation. >>> >>> >>> 'Aborting the simulation' as in aborting the whole operation makes H not >>> a proper halt decider, unless H^ was built as a seperate program that >>> exec'ed the decider to get the answer, but I don't think your simulator >>> can handle that case. >>> >>> You NEED for the outer H to return the answer. >> >> That is why I changed it so that it does it that way now. >> >>> >>>> >>>>>> >>>>>>> Remember each instance represents its own computation, >>>>>>> and that computation must generate that same answer for the same >>>>>>> inputs. >>>>>>> >>>>>> >>>>>> That seems to mean that every function called in infinite recursion is >>>>>> not allowed to keep track that it was called in infinite recursion. >>>>> >>>>> No, it does not say that. Since every level of the decider WILL abort >>>>> its simulation in a finite amount of time, there NEVER WAS an infinite >>>>> recursion at any point. >>>>> >>>> >>>> This is the part that is over your head. >>>> It took me at least three days to understand this myself. >>>> >>>> Unless the first H that sees the infinite behavior aborts its simulation >>>> no H ever aborts its simulation. >>> >>> >>> WRONG. Your are doing your logic backwards. >>> >>> The algorithm for H has to be determined FIRST. >>> >>> Once this is established then either H WILL abort H^(H^) or H will not >>> abort H^*H^). >>> >>> If H doesn't abort H^(H^) then H will never answer the question H(H^,H^) >>> >>> If H does abort H^(H^) then there is NO infinite behavior in the system >>> at all, BECAUSE H will abort it in finite time and H needs to take that >>> behavior of the copies of H it is simulating into account. >>> >> >> There is Olcott H1/H/P and Linz H/Ĥ >> Whenever I am talking about Ĥ I am only taling about Linz. > > > And your H1/H show that either H1/H are two different computations, and > thus H1 is NOT the H that disprove Linz, or H1/H isn't actually a > computation and thus doesn't disprove Linz. > > FAIL. My H1/H are the same two different computations that the Linz H/Ĥ are. Olcott H1 does not have pathological self reference Olcott H has pathological self reference Linz H does not have pathological self reference Linz Ĥ has pathological self reference > >> >>> Anytime you use logic postulating over different version of H, you are >>> likely doing it wrong. >>> >>>> >>>> It it like being stuck in an infinite loop where you keep saying that >>>> you will mow the lawn tomorrow. When tomorrow arrives you will still mow >>>> the law tomorrow yet now tomorrow refers to a different day. >>> >>> >>> Right, but that isn't the case here. STRAWMAN. >>> >>> EVERY H will abort its simulation after a finite amount of work, and >> >> No H ever aborts any simulation of its input unless this input is >> aborted at a fixed number of recursive simulations. I set this limit at >> the smallest number of 2. > > You need to define what you H does. PERIOD. This 'No H' is just proving > the point > > If H doesn't abort, then H doesn't answer and fails. > Olcott H aborts the simulation of its input as soon as its input calls H exactly two times. > If H does abort, H^/P Halts and H is wrong. > > It doesn't matter WHY H^/P Halts, just that it does. > > FAIL > >> >> If H keeps waiting for the next H to abort the simulation of its input >> that it like you saying that you will mow the lawn tomorrow every single >> day. > > Yes, and that version of H never answers, so it is wrong. > >> >> On Tuesday you say tommorow, then on Wednesday you say tomorrow... >> >> When I say exact two iterations on Tuesday I am saying that the lawn >> will be mowed on Wednesday. As soon as Wednesday gets here (exactly two >> recursive simulations) it is now time to mow the lawn (abort the input). >> >> > > And for the H that does abort, there never was an infinite execution so > H^/P is halting. > > Again, it doesn't matter WHY H^/P end up halting, the fact that it does > means that it is halting. > > The trace pattern that H calls as the proof of non-halting behavior is > identical to the piece of the trace of H^/P that halted, thus calling it > proof of non-halting is incorrect. > -- 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-18 18:01 -0400 |
| Subject | Re: Why do theory of computation problems require pure functions? [mow lawn] |
| Message-ID | <0lt1J.169006$T_8.127397@fx48.iad> |
| In reply to | #39472 |
On 9/18/21 5:48 PM, olcott wrote: > On 9/18/2021 4:38 PM, Richard Damon wrote: >> On 9/18/21 5:22 PM, olcott wrote: >>> On 9/18/2021 3:55 PM, Richard Damon wrote: >>>> On 9/18/21 4:07 PM, olcott wrote: >>>>> On 9/18/2021 2:52 PM, Richard Damon wrote: >>>>>> On 9/18/21 3:30 PM, olcott wrote: >>>>>>> On 9/18/2021 2:08 PM, Richard Damon wrote: >>>>>>>> On 9/18/21 12:50 PM, olcott wrote: >>>>>>>>> On 9/18/2021 11:28 AM, Richard Damon wrote: >>>>>>>>>> On 9/18/21 12:15 PM, olcott wrote: >>>>>>>>>>> On 9/18/2021 10:52 AM, Richard Damon wrote: >>>>>>>>>>>> On 9/18/21 11:39 AM, olcott wrote: >>>>>>>>>>>>> On 9/18/2021 10:37 AM, Richard Damon wrote: >>>>>>>>>>>>>> On 9/18/21 11:29 AM, olcott wrote: >>>>>>>>>>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote: >>>>>>>>>>>>>>>> On 9/18/21 11:17 AM, olcott wrote: >>>>>>>>>>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>>>>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> I either must stick with C/x86 code or write a RASP >>>>>>>>>>>>>>>>>>> machine, the >>>>>>>>>>>>>>>>>>> only >>>>>>>>>>>>>>>>>>> way that my key insights can possible be fully >>>>>>>>>>>>>>>>>>> understood >>>>>>>>>>>>>>>>>>> is to >>>>>>>>>>>>>>>>>>> have >>>>>>>>>>>>>>>>>>> every single detail as fully operational code such that >>>>>>>>>>>>>>>>>>> we can >>>>>>>>>>>>>>>>>>> simply >>>>>>>>>>>>>>>>>>> see what it does and thus not merely imagine what it >>>>>>>>>>>>>>>>>>> would do. >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> Why do you insist on continuously repeating this rather >>>>>>>>>>>>>>>>>> ridiculous >>>>>>>>>>>>>>>>>> claim? >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> When working with Turing Machines one doesn't need to >>>>>>>>>>>>>>>>>> 'merely >>>>>>>>>>>>>>>>>> imagine >>>>>>>>>>>>>>>>>> what it would do.' One can see *exactly* what it does. >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> André >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> When H is defined as a simulating halt decider then H >>>>>>>>>>>>>>>>> correctly >>>>>>>>>>>>>>>>> decides >>>>>>>>>>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting >>>>>>>>>>>>>>>> when it >>>>>>>>>>>>>>>> actually >>>>>>>>>>>>>>>> Halts. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> Which says that it is deciding that H^(<H^>) is a non-halting >>>>>>>>>>>>>> computation, but if we run H^(<H^>) it ends up at its >>>>>>>>>>>>>> terminal >>>>>>>>>>>>>> state >>>>>>>>>>>>>> H^.qy which halts. (Since the code for H^ is derived from the >>>>>>>>>>>>>> code >>>>>>>>>>>>>> of H, >>>>>>>>>>>>>> and the state H^.qn is the corresponding state to H.qn) >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> So does my use of a static local variable by itself make my >>>>>>>>>>>>> code not >>>>>>>>>>>>> apply to the halting problem or not? >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> No, but that doesn't mean that the presence of the static local >>>>>>>>>>>> variable >>>>>>>>>>>> is unconditionally allowed. >>>>>>>>>>>> >>>>>>>>>>>> You need to PROVE that your program is a Computation. >>>>>>>>>>>> >>>>>>>>>>>> Lack of things like static local variables make that proof much >>>>>>>>>>>> easier. >>>>>>>>>>>> as if all information inside the program can only be derived >>>>>>>>>>>> from the >>>>>>>>>>>> official input, then there is no source of 'illegal' >>>>>>>>>>>> information. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> The halt status decision is entirely based on the execution >>>>>>>>>>> trace >>>>>>>>>>> derived from the input machine address pair. >>>>>>>>>> >>>>>>>>>> Right, but that ALSO applies to the simulated copies of H, which >>>>>>>>>> need to >>>>>>>>>> give the exact same answer given the exact same input. >>>>>>>>>> >>>>>>>>> >>>>>>>>> The original way that it worked was that the very first slave >>>>>>>>> that saw >>>>>>>>> that an infinite behavior pattern was matched reported this >>>>>>>>> through a >>>>>>>>> static variable that every master/slave instance of H used as >>>>>>>>> their >>>>>>>>> while (**Aborted == 0) termination condition. >>>>>>>>> >>>>>>>>> Then I changed this so that only the master made the halt status >>>>>>>>> decision. Its trigger for testing the halt status was that the >>>>>>>>> local >>>>>>>>> static execution trace is longer than it was the last time that it >>>>>>>>> tested the halt status. >>>>>>>> >>>>>>>> The key is that the system needs to be setup so that each of the >>>>>>>> 'slave' >>>>>>>> H's would also generate that exact same answer if the outer copy >>>>>>>> (and >>>>>>>> just that copy) is modified to not abort to allow the testing of it >>>>>>>> being right in deciding to abort. >>>>>>>> >>>>>>> >>>>>>> The inner and outer generate the exact same answer. The inner >>>>>>> used to >>>>>>> generate the answer and now the outer generates the same answer. >>>>>>> If I >>>>>>> don't force it to decide at a certain point then the inner one that >>>>>>> reports that its input never halts is the one that has reached the >>>>>>> deepest recursion depth and thus sees more of the execution trace >>>>>>> before >>>>>>> the other ones. >>>>>> >>>>>> So, you are admitting that the slave H WILL return the Non-Halting >>>>>> answer in finite time and thus the H^ that called it was NOT in >>>>>> infinite >>>>>> recursion and does itself Halt in finite time? >>>>>> >>>>> >>>>> There is no H^. This is only the C/x86 code that has H1/H. >>>> >>>> If you have no code that matches the H^ in the Linz proof, then you >>>> aren't talking about it. >>>> >>>> You, for some strange reason, see to want to call this P. >>>> >>>> The fact that you don't seem to understand the ^ operator of Linz makes >>>> me wonder how much you actually understand what the proof is talking >>>> about. >>>> >>>> >>>>> >>>>>> THAT is the implication that the slave H will behave exactly the >>>>>> same as >>>>>> the master. >>>>>> >>>>>>> >>>>>>>>> >>>>>>>>>> This means that since the 'master' H(P,P) returns non-halting, >>>>>>>>>> that >>>>>>>>>> must >>>>>>>>>> be consistent with the copy of H inside P ALSO return the >>>>>>>>>> answer of >>>>>>>>>> non-halting when given that exact same input. >>>>>>>>>> >>>>>>>>>> The 'assumption' that it will not return is a violation of that. >>>>>>>>>> >>>>>>>>>> Either H is using unsound logic, or H is not a computation >>>>>>>>>> because >>>>>>>>>> the >>>>>>>>>> 'slave' H doesn't behave the same way. >>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>>> Presence of things like static local variables don't by >>>>>>>>>>>> themselves >>>>>>>>>>>> invalidate you ability to be a Computation, but do mean you >>>>>>>>>>>> really do >>>>>>>>>>>> need to show that it is one. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> That is great. What are the requirements of a computation? >>>>>>>>>>> >>>>>>>>>>> given an input of the function domain it can return the >>>>>>>>>>> corresponding >>>>>>>>>>> output. https://en.wikipedia.org/wiki/Computable_function >>>>>>>>>> >>>>>>>>>> It is a bit more that a function with a specific value for a >>>>>>>>>> specific >>>>>>>>>> input, as it also needs to be the results of an 'algorithm', a >>>>>>>>>> step by >>>>>>>>>> step listing of instructions to get to the result. >>>>>>>>>> >>>>>>>>>> If all of the inputs to the algorithm are part of the formal >>>>>>>>>> input to >>>>>>>>>> the function, then you get a computation. >>>>>>>>>> >>>>>>>>> >>>>>>>>> Formal input is typically restricted to input parameters. >>>>>>>>> The use of the static local execution_trace is to store >>>>>>>>> intermediate >>>>>>>>> results that are derived on the basis of the input parameters. >>>>>>>> >>>>>>>> Watch out, input parameters are for THAT INSTANCE, so a slave >>>>>>>> instance >>>>>>>> can't act differently (as far as its caller can tell) just because >>>>>>>> it is >>>>>>>> a slave instance. >>>>>>> >>>>>>> Yet in this case that is simply factually incorrect. The deeper >>>>>>> that the >>>>>>> recursive simulation goes the longer the execution trace becomes. As >>>>>>> soon as the execution trace is long enough to match an infinitely >>>>>>> repeating pattern simulation is aborted. >>>>>>> >>>>>>> Without a static local variable it is impossible for the halt >>>>>>> decider to >>>>>>> see that it has ever been invoked more than once. Without a static >>>>>>> local >>>>>>> variable every time that it is invoked its execution trace is >>>>>>> emptied. >>>>>> >>>>>> Again, it isn't the fact that the static local variable exist that >>>>>> causes the problem, but EVERY copy of the decider needs to act >>>>>> exactly >>>>>> the same to its caller when provided the exact same inputs. >>>>>> >>>>>> So the slave Hs need to be able and considered to abort their own >>>>>> simulations just like the master did, and thus reveal that the master >>>>>> was in error in assuming they would not. >>>>>> >>>>> >>>>> The way that it originally worked was that the first recursive >>>>> simulation of H that saw P called H twice in a row was the one that >>>>> aborted the simulation. >>>> >>>> >>>> 'Aborting the simulation' as in aborting the whole operation makes H >>>> not >>>> a proper halt decider, unless H^ was built as a seperate program that >>>> exec'ed the decider to get the answer, but I don't think your simulator >>>> can handle that case. >>>> >>>> You NEED for the outer H to return the answer. >>> >>> That is why I changed it so that it does it that way now. >>> >>>> >>>>> >>>>>>> >>>>>>>> Remember each instance represents its own computation, >>>>>>>> and that computation must generate that same answer for the same >>>>>>>> inputs. >>>>>>>> >>>>>>> >>>>>>> That seems to mean that every function called in infinite >>>>>>> recursion is >>>>>>> not allowed to keep track that it was called in infinite recursion. >>>>>> >>>>>> No, it does not say that. Since every level of the decider WILL abort >>>>>> its simulation in a finite amount of time, there NEVER WAS an >>>>>> infinite >>>>>> recursion at any point. >>>>>> >>>>> >>>>> This is the part that is over your head. >>>>> It took me at least three days to understand this myself. >>>>> >>>>> Unless the first H that sees the infinite behavior aborts its >>>>> simulation >>>>> no H ever aborts its simulation. >>>> >>>> >>>> WRONG. Your are doing your logic backwards. >>>> >>>> The algorithm for H has to be determined FIRST. >>>> >>>> Once this is established then either H WILL abort H^(H^) or H will not >>>> abort H^*H^). >>>> >>>> If H doesn't abort H^(H^) then H will never answer the question >>>> H(H^,H^) >>>> >>>> If H does abort H^(H^) then there is NO infinite behavior in the system >>>> at all, BECAUSE H will abort it in finite time and H needs to take that >>>> behavior of the copies of H it is simulating into account. >>>> >>> >>> There is Olcott H1/H/P and Linz H/Ĥ >>> Whenever I am talking about Ĥ I am only taling about Linz. >> >> >> And your H1/H show that either H1/H are two different computations, and >> thus H1 is NOT the H that disprove Linz, or H1/H isn't actually a >> computation and thus doesn't disprove Linz. >> >> FAIL. > > My H1/H are the same two different computations that the Linz H/Ĥ are. NO!!! Olcott H is NOT Linz H^, Your H is only the piece of Linz H^ that is supposed to be the copy of Linz H. FAIL. > > Olcott H1 does not have pathological self reference > Olcott H has pathological self referenceLinz H > > Linz H does not have pathological self reference > Linz Ĥ has pathological self reference Linz H^ does NOT have ANY self-reference in the machince itself. H^ only references the machine H, no self-reference at all. The Computation H^(<H^>) isn't even really a self-reference, as <H^> does NOT have any definition of 'self' in it, it is NOT refering to the machine it is applied to. It is just a representation of a Machine, a perfectly normal sort of input. Note, Turing Machine are incapable of actually providing a 'self-reference' on the tape for the machine. >> >>> >>>> Anytime you use logic postulating over different version of H, you are >>>> likely doing it wrong. >>>> >>>>> >>>>> It it like being stuck in an infinite loop where you keep saying that >>>>> you will mow the lawn tomorrow. When tomorrow arrives you will >>>>> still mow >>>>> the law tomorrow yet now tomorrow refers to a different day. >>>> >>>> >>>> Right, but that isn't the case here. STRAWMAN. >>>> >>>> EVERY H will abort its simulation after a finite amount of work, and >>> >>> No H ever aborts any simulation of its input unless this input is >>> aborted at a fixed number of recursive simulations. I set this limit at >>> the smallest number of 2. >> >> You need to define what you H does. PERIOD. This 'No H' is just proving >> the point >> >> If H doesn't abort, then H doesn't answer and fails. >> > > Olcott H aborts the simulation of its input as soon as its input calls H > exactly two times. Ok, so the computation P(<P>) that it is simulating, when run as an independent machine also Halts, showing that H's decision to call the input a representation of a non-halting machine wrong. If H does abort its simulation, you aren't in THIS case but the one below that you seem to ignore. > >> If H does abort, H^/P Halts and H is wrong. >> >> It doesn't matter WHY H^/P Halts, just that it does. >> >> FAIL >> >>> >>> If H keeps waiting for the next H to abort the simulation of its input >>> that it like you saying that you will mow the lawn tomorrow every single >>> day. >> >> Yes, and that version of H never answers, so it is wrong. >> >>> >>> On Tuesday you say tommorow, then on Wednesday you say tomorrow... >>> >>> When I say exact two iterations on Tuesday I am saying that the lawn >>> will be mowed on Wednesday. As soon as Wednesday gets here (exactly two >>> recursive simulations) it is now time to mow the lawn (abort the input). >>> >>> >> >> And for the H that does abort, there never was an infinite execution so >> H^/P is halting. >> >> Again, it doesn't matter WHY H^/P end up halting, the fact that it does >> means that it is halting. >> >> The trace pattern that H calls as the proof of non-halting behavior is >> identical to the piece of the trace of H^/P that halted, thus calling it >> proof of non-halting is incorrect. >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-18 17:10 -0500 |
| Subject | Re: Why do theory of computation problems require pure functions? [defeat Rice] |
| Message-ID | <Fv6dnVZPFtRd_tv8nZ2dnUU7-fnNnZ2d@giganews.com> |
| In reply to | #39479 |
On 9/18/2021 5:01 PM, Richard Damon wrote:
> On 9/18/21 5:48 PM, olcott wrote:
>> On 9/18/2021 4:38 PM, Richard Damon wrote:
>>> On 9/18/21 5:22 PM, olcott wrote:
>>>> On 9/18/2021 3:55 PM, Richard Damon wrote:
>>>>> On 9/18/21 4:07 PM, olcott wrote:
>>>>>> On 9/18/2021 2:52 PM, Richard Damon wrote:
>>>>>>> On 9/18/21 3:30 PM, olcott wrote:
>>>>>>>> On 9/18/2021 2:08 PM, Richard Damon wrote:
>>>>>>>>> On 9/18/21 12:50 PM, olcott wrote:
>>>>>>>>>> On 9/18/2021 11:28 AM, Richard Damon wrote:
>>>>>>>>>>> On 9/18/21 12:15 PM, olcott wrote:
>>>>>>>>>>>> On 9/18/2021 10:52 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/18/21 11:39 AM, olcott wrote:
>>>>>>>>>>>>>> On 9/18/2021 10:37 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/18/21 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/18/21 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>> On 2021-09-18 07:57, olcott wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I either must stick with C/x86 code or write a RASP
>>>>>>>>>>>>>>>>>>>> machine, the
>>>>>>>>>>>>>>>>>>>> only
>>>>>>>>>>>>>>>>>>>> way that my key insights can possible be fully
>>>>>>>>>>>>>>>>>>>> understood
>>>>>>>>>>>>>>>>>>>> is to
>>>>>>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>>>>>>> every single detail as fully operational code such that
>>>>>>>>>>>>>>>>>>>> we can
>>>>>>>>>>>>>>>>>>>> simply
>>>>>>>>>>>>>>>>>>>> see what it does and thus not merely imagine what it
>>>>>>>>>>>>>>>>>>>> would do.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Why do you insist on continuously repeating this rather
>>>>>>>>>>>>>>>>>>> ridiculous
>>>>>>>>>>>>>>>>>>> claim?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When working with Turing Machines one doesn't need to
>>>>>>>>>>>>>>>>>>> 'merely
>>>>>>>>>>>>>>>>>>> imagine
>>>>>>>>>>>>>>>>>>> what it would do.' One can see *exactly* what it does.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When H is defined as a simulating halt decider then H
>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>> decides
>>>>>>>>>>>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting
>>>>>>>>>>>>>>>>> when it
>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>> Halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which says that it is deciding that H^(<H^>) is a non-halting
>>>>>>>>>>>>>>> computation, but if we run H^(<H^>) it ends up at its
>>>>>>>>>>>>>>> terminal
>>>>>>>>>>>>>>> state
>>>>>>>>>>>>>>> H^.qy which halts. (Since the code for H^ is derived from the
>>>>>>>>>>>>>>> code
>>>>>>>>>>>>>>> of H,
>>>>>>>>>>>>>>> and the state H^.qn is the corresponding state to H.qn)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So does my use of a static local variable by itself make my
>>>>>>>>>>>>>> code not
>>>>>>>>>>>>>> apply to the halting problem or not?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, but that doesn't mean that the presence of the static local
>>>>>>>>>>>>> variable
>>>>>>>>>>>>> is unconditionally allowed.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You need to PROVE that your program is a Computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Lack of things like static local variables make that proof much
>>>>>>>>>>>>> easier.
>>>>>>>>>>>>> as if all information inside the program can only be derived
>>>>>>>>>>>>> from the
>>>>>>>>>>>>> official input, then there is no source of 'illegal'
>>>>>>>>>>>>> information.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The halt status decision is entirely based on the execution
>>>>>>>>>>>> trace
>>>>>>>>>>>> derived from the input machine address pair.
>>>>>>>>>>>
>>>>>>>>>>> Right, but that ALSO applies to the simulated copies of H, which
>>>>>>>>>>> need to
>>>>>>>>>>> give the exact same answer given the exact same input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The original way that it worked was that the very first slave
>>>>>>>>>> that saw
>>>>>>>>>> that an infinite behavior pattern was matched reported this
>>>>>>>>>> through a
>>>>>>>>>> static variable that every master/slave instance of H used as
>>>>>>>>>> their
>>>>>>>>>> while (**Aborted == 0) termination condition.
>>>>>>>>>>
>>>>>>>>>> Then I changed this so that only the master made the halt status
>>>>>>>>>> decision. Its trigger for testing the halt status was that the
>>>>>>>>>> local
>>>>>>>>>> static execution trace is longer than it was the last time that it
>>>>>>>>>> tested the halt status.
>>>>>>>>>
>>>>>>>>> The key is that the system needs to be setup so that each of the
>>>>>>>>> 'slave'
>>>>>>>>> H's would also generate that exact same answer if the outer copy
>>>>>>>>> (and
>>>>>>>>> just that copy) is modified to not abort to allow the testing of it
>>>>>>>>> being right in deciding to abort.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The inner and outer generate the exact same answer. The inner
>>>>>>>> used to
>>>>>>>> generate the answer and now the outer generates the same answer.
>>>>>>>> If I
>>>>>>>> don't force it to decide at a certain point then the inner one that
>>>>>>>> reports that its input never halts is the one that has reached the
>>>>>>>> deepest recursion depth and thus sees more of the execution trace
>>>>>>>> before
>>>>>>>> the other ones.
>>>>>>>
>>>>>>> So, you are admitting that the slave H WILL return the Non-Halting
>>>>>>> answer in finite time and thus the H^ that called it was NOT in
>>>>>>> infinite
>>>>>>> recursion and does itself Halt in finite time?
>>>>>>>
>>>>>>
>>>>>> There is no H^. This is only the C/x86 code that has H1/H.
>>>>>
>>>>> If you have no code that matches the H^ in the Linz proof, then you
>>>>> aren't talking about it.
>>>>>
>>>>> You, for some strange reason, see to want to call this P.
>>>>>
>>>>> The fact that you don't seem to understand the ^ operator of Linz makes
>>>>> me wonder how much you actually understand what the proof is talking
>>>>> about.
>>>>>
>>>>>
>>>>>>
>>>>>>> THAT is the implication that the slave H will behave exactly the
>>>>>>> same as
>>>>>>> the master.
>>>>>>>
>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> This means that since the 'master' H(P,P) returns non-halting,
>>>>>>>>>>> that
>>>>>>>>>>> must
>>>>>>>>>>> be consistent with the copy of H inside P ALSO return the
>>>>>>>>>>> answer of
>>>>>>>>>>> non-halting when given that exact same input.
>>>>>>>>>>>
>>>>>>>>>>> The 'assumption' that it will not return is a violation of that.
>>>>>>>>>>>
>>>>>>>>>>> Either H is using unsound logic, or H is not a computation
>>>>>>>>>>> because
>>>>>>>>>>> the
>>>>>>>>>>> 'slave' H doesn't behave the same way.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> Presence of things like static local variables don't by
>>>>>>>>>>>>> themselves
>>>>>>>>>>>>> invalidate you ability to be a Computation, but do mean you
>>>>>>>>>>>>> really do
>>>>>>>>>>>>> need to show that it is one.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That is great. What are the requirements of a computation?
>>>>>>>>>>>>
>>>>>>>>>>>> given an input of the function domain it can return the
>>>>>>>>>>>> corresponding
>>>>>>>>>>>> output. https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>
>>>>>>>>>>> It is a bit more that a function with a specific value for a
>>>>>>>>>>> specific
>>>>>>>>>>> input, as it also needs to be the results of an 'algorithm', a
>>>>>>>>>>> step by
>>>>>>>>>>> step listing of instructions to get to the result.
>>>>>>>>>>>
>>>>>>>>>>> If all of the inputs to the algorithm are part of the formal
>>>>>>>>>>> input to
>>>>>>>>>>> the function, then you get a computation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Formal input is typically restricted to input parameters.
>>>>>>>>>> The use of the static local execution_trace is to store
>>>>>>>>>> intermediate
>>>>>>>>>> results that are derived on the basis of the input parameters.
>>>>>>>>>
>>>>>>>>> Watch out, input parameters are for THAT INSTANCE, so a slave
>>>>>>>>> instance
>>>>>>>>> can't act differently (as far as its caller can tell) just because
>>>>>>>>> it is
>>>>>>>>> a slave instance.
>>>>>>>>
>>>>>>>> Yet in this case that is simply factually incorrect. The deeper
>>>>>>>> that the
>>>>>>>> recursive simulation goes the longer the execution trace becomes. As
>>>>>>>> soon as the execution trace is long enough to match an infinitely
>>>>>>>> repeating pattern simulation is aborted.
>>>>>>>>
>>>>>>>> Without a static local variable it is impossible for the halt
>>>>>>>> decider to
>>>>>>>> see that it has ever been invoked more than once. Without a static
>>>>>>>> local
>>>>>>>> variable every time that it is invoked its execution trace is
>>>>>>>> emptied.
>>>>>>>
>>>>>>> Again, it isn't the fact that the static local variable exist that
>>>>>>> causes the problem, but EVERY copy of the decider needs to act
>>>>>>> exactly
>>>>>>> the same to its caller when provided the exact same inputs.
>>>>>>>
>>>>>>> So the slave Hs need to be able and considered to abort their own
>>>>>>> simulations just like the master did, and thus reveal that the master
>>>>>>> was in error in assuming they would not.
>>>>>>>
>>>>>>
>>>>>> The way that it originally worked was that the first recursive
>>>>>> simulation of H that saw P called H twice in a row was the one that
>>>>>> aborted the simulation.
>>>>>
>>>>>
>>>>> 'Aborting the simulation' as in aborting the whole operation makes H
>>>>> not
>>>>> a proper halt decider, unless H^ was built as a seperate program that
>>>>> exec'ed the decider to get the answer, but I don't think your simulator
>>>>> can handle that case.
>>>>>
>>>>> You NEED for the outer H to return the answer.
>>>>
>>>> That is why I changed it so that it does it that way now.
>>>>
>>>>>
>>>>>>
>>>>>>>>
>>>>>>>>> Remember each instance represents its own computation,
>>>>>>>>> and that computation must generate that same answer for the same
>>>>>>>>> inputs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That seems to mean that every function called in infinite
>>>>>>>> recursion is
>>>>>>>> not allowed to keep track that it was called in infinite recursion.
>>>>>>>
>>>>>>> No, it does not say that. Since every level of the decider WILL abort
>>>>>>> its simulation in a finite amount of time, there NEVER WAS an
>>>>>>> infinite
>>>>>>> recursion at any point.
>>>>>>>
>>>>>>
>>>>>> This is the part that is over your head.
>>>>>> It took me at least three days to understand this myself.
>>>>>>
>>>>>> Unless the first H that sees the infinite behavior aborts its
>>>>>> simulation
>>>>>> no H ever aborts its simulation.
>>>>>
>>>>>
>>>>> WRONG. Your are doing your logic backwards.
>>>>>
>>>>> The algorithm for H has to be determined FIRST.
>>>>>
>>>>> Once this is established then either H WILL abort H^(H^) or H will not
>>>>> abort H^*H^).
>>>>>
>>>>> If H doesn't abort H^(H^) then H will never answer the question
>>>>> H(H^,H^)
>>>>>
>>>>> If H does abort H^(H^) then there is NO infinite behavior in the system
>>>>> at all, BECAUSE H will abort it in finite time and H needs to take that
>>>>> behavior of the copies of H it is simulating into account.
>>>>>
>>>>
>>>> There is Olcott H1/H/P and Linz H/Ĥ
>>>> Whenever I am talking about Ĥ I am only taling about Linz.
>>>
>>>
>>> And your H1/H show that either H1/H are two different computations, and
>>> thus H1 is NOT the H that disprove Linz, or H1/H isn't actually a
>>> computation and thus doesn't disprove Linz.
>>>
>>> FAIL.
>>
>> My H1/H are the same two different computations that the Linz H/Ĥ are.
>
> NO!!!
>
> Olcott H is NOT Linz H^, Your H is only the piece of Linz H^ that is
> supposed to be the copy of Linz H.
>
> FAIL.
>
>>
>> Olcott H1 does not have pathological self reference
>> Olcott H has pathological self referenceLinz H
>>
>> Linz H does not have pathological self reference
>> Linz Ĥ has pathological self reference
>
> Linz H^ does NOT have ANY self-reference in the machince itself. H^ only
> references the machine H, no self-reference at all.
>
> The Computation H^(<H^>) isn't even really a self-reference, as <H^>
> does NOT have any definition of 'self' in it, it is NOT refering to the
> machine it is applied to. It is just a representation of a Machine, a
> perfectly normal sort of input.
>
> Note, Turing Machine are incapable of actually providing a
> 'self-reference' on the tape for the machine.
>
>>>
>>>>
>>>>> Anytime you use logic postulating over different version of H, you are
>>>>> likely doing it wrong.
>>>>>
>>>>>>
>>>>>> It it like being stuck in an infinite loop where you keep saying that
>>>>>> you will mow the lawn tomorrow. When tomorrow arrives you will
>>>>>> still mow
>>>>>> the law tomorrow yet now tomorrow refers to a different day.
>>>>>
>>>>>
>>>>> Right, but that isn't the case here. STRAWMAN.
>>>>>
>>>>> EVERY H will abort its simulation after a finite amount of work, and
>>>>
>>>> No H ever aborts any simulation of its input unless this input is
>>>> aborted at a fixed number of recursive simulations. I set this limit at
>>>> the smallest number of 2.
>>>
>>> You need to define what you H does. PERIOD. This 'No H' is just proving
>>> the point
>>>
>>> If H doesn't abort, then H doesn't answer and fails.
>>>
>>
>> Olcott H aborts the simulation of its input as soon as its input calls H
>> exactly two times.
>
> Ok, so the computation P(<P>) that it is simulating, when run as an
> independent machine also Halts, showing that H's decision to call the
> input a representation of a non-halting machine wrong.
>
This explains that:
int main()
{
if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
OutputString("Pathological self-reference error!");
}
H1 does not have the Pathological self-reference error, and derives a
halt status consistent with the behavior of P(P).
> If H does abort its simulation, you aren't in THIS case but the one
> below that you seem to ignore.
>
>>
>>> If H does abort, H^/P Halts and H is wrong.
>>>
>>> It doesn't matter WHY H^/P Halts, just that it does.
>>>
>>> FAIL
>>>
>>>>
>>>> If H keeps waiting for the next H to abort the simulation of its input
>>>> that it like you saying that you will mow the lawn tomorrow every single
>>>> day.
>>>
>>> Yes, and that version of H never answers, so it is wrong.
>>>
>>>>
>>>> On Tuesday you say tommorow, then on Wednesday you say tomorrow...
>>>>
>>>> When I say exact two iterations on Tuesday I am saying that the lawn
>>>> will be mowed on Wednesday. As soon as Wednesday gets here (exactly two
>>>> recursive simulations) it is now time to mow the lawn (abort the input).
>>>>
>>>>
>>>
>>> And for the H that does abort, there never was an infinite execution so
>>> H^/P is halting.
>>>
>>> Again, it doesn't matter WHY H^/P end up halting, the fact that it does
>>> means that it is halting.
>>>
>>> The trace pattern that H calls as the proof of non-halting behavior is
>>> identical to the piece of the trace of H^/P that halted, thus calling it
>>> proof of non-halting is incorrect.
>>>
>>
>>
>
--
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-18 18:26 -0400 |
| Subject | Re: Why do theory of computation problems require pure functions? [defeat Rice] |
| Message-ID | <AIt1J.42633$3p3.17937@fx16.iad> |
| In reply to | #39482 |
On 9/18/21 6:10 PM, olcott wrote:
> On 9/18/2021 5:01 PM, Richard Damon wrote:
>> Ok, so the computation P(<P>) that it is simulating, when run as an
>> independent machine also Halts, showing that H's decision to call the
>> input a representation of a non-halting machine wrong.
>>
>
> This explains that:
>
> int main()
> {
> if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
> OutputString("Pathological self-reference error!");
> }
>
> H1 does not have the Pathological self-reference error, and derives a
> halt status consistent with the behavior of P(P).
There is NO 'Pathelogicial Self-Reference Error', that is a figment of
your own mind. <H^> <H^> is a perfectly legal and valid input for the
decider H.
All you are showing is that you KNOW that PO-H gets the wrong answer,
and PO-H1 gets the right answer, but it is PO-H that matters as that is
the machihe that PO-P is built on.
FAIL.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-18 22:55 +0100 |
| Message-ID | <874kahblap.fsf@bsb.me.uk> |
| In reply to | #39413 |
olcott <polcott2@gmail.com> writes: > H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy. See my other replies about why you claim something else as well. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-18 10:10 -0600 |
| Message-ID | <si531f$q3f$2@dont-email.me> |
| In reply to | #39407 |
On 2021-09-18 09:17, olcott wrote: > On 9/18/2021 10:04 AM, André G. Isaak wrote: >> On 2021-09-18 07:57, olcott wrote: >> >>> I either must stick with C/x86 code or write a RASP machine, the only >>> way that my key insights can possible be fully understood is to have >>> every single detail as fully operational code such that we can simply >>> see what it does and thus not merely imagine what it would do. >> >> Why do you insist on continuously repeating this rather ridiculous claim? >> >> When working with Turing Machines one doesn't need to 'merely imagine >> what it would do.' One can see *exactly* what it does. >> >> André >> > > When H is defined as a simulating halt decider then H correctly decides > the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. And this statement relates to my post how exactly? André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-18 11:39 -0500 |
| Message-ID | <CtmdnXIC2u_Di9v8nZ2dnUU7-R3NnZ2d@giganews.com> |
| In reply to | #39424 |
On 9/18/2021 11:10 AM, André G. Isaak wrote: > On 2021-09-18 09:17, olcott wrote: >> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>> On 2021-09-18 07:57, olcott wrote: >>> >>>> I either must stick with C/x86 code or write a RASP machine, the >>>> only way that my key insights can possible be fully understood is to >>>> have every single detail as fully operational code such that we can >>>> simply see what it does and thus not merely imagine what it would do. >>> >>> Why do you insist on continuously repeating this rather ridiculous >>> claim? >>> >>> When working with Turing Machines one doesn't need to 'merely imagine >>> what it would do.' One can see *exactly* what it does. >>> >>> André >>> >> >> When H is defined as a simulating halt decider then H correctly >> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. > > And this statement relates to my post how exactly? > > André > > How can [One can see *exactly* what it does] show that my claim that simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly decide the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ? -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-18 10:52 -0600 |
| Message-ID | <si55gs$aa2$1@dont-email.me> |
| In reply to | #39432 |
On 2021-09-18 10:39, olcott wrote: > On 9/18/2021 11:10 AM, André G. Isaak wrote: >> On 2021-09-18 09:17, olcott wrote: >>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>> On 2021-09-18 07:57, olcott wrote: >>>> >>>>> I either must stick with C/x86 code or write a RASP machine, the >>>>> only way that my key insights can possible be fully understood is >>>>> to have every single detail as fully operational code such that we >>>>> can simply see what it does and thus not merely imagine what it >>>>> would do. >>>> >>>> Why do you insist on continuously repeating this rather ridiculous >>>> claim? >>>> >>>> When working with Turing Machines one doesn't need to 'merely >>>> imagine what it would do.' One can see *exactly* what it does. >>>> >>>> André >>>> >>> >>> When H is defined as a simulating halt decider then H correctly >>> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >> >> And this statement relates to my post how exactly? >> >> André >> >> > > How can [One can see *exactly* what it does] show that my claim that > simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly decide > the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ? I made no claims whatsoever in my post about your H. I questioned your repeated assertion that if you don't have fully operational c/x86 code you have to imagine all the details. You keep asserting that with Turing Machine you must 'imagine' all the details which is simply false. André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-18 12:08 -0500 |
| Message-ID | <L5-dnUtHucSVgNv8nZ2dnUU7-X_NnZ2d@giganews.com> |
| In reply to | #39434 |
On 9/18/2021 11:52 AM, André G. Isaak wrote: > On 2021-09-18 10:39, olcott wrote: >> On 9/18/2021 11:10 AM, André G. Isaak wrote: >>> On 2021-09-18 09:17, olcott wrote: >>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>> On 2021-09-18 07:57, olcott wrote: >>>>> >>>>>> I either must stick with C/x86 code or write a RASP machine, the >>>>>> only way that my key insights can possible be fully understood is >>>>>> to have every single detail as fully operational code such that we >>>>>> can simply see what it does and thus not merely imagine what it >>>>>> would do. >>>>> >>>>> Why do you insist on continuously repeating this rather ridiculous >>>>> claim? >>>>> >>>>> When working with Turing Machines one doesn't need to 'merely >>>>> imagine what it would do.' One can see *exactly* what it does. >>>>> >>>>> André >>>>> >>>> >>>> When H is defined as a simulating halt decider then H correctly >>>> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>> >>> And this statement relates to my post how exactly? >>> >>> André >>> >>> >> >> How can [One can see *exactly* what it does] show that my claim that >> simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly decide >> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ? > > I made no claims whatsoever in my post about your H. This is exactly what I mean by dishonest dodge AKA the strawman error. When we examine the Peter Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ there is nothing in the peter Linz text where [One can see *exactly* what it does] when we assume that the Peter Linz H/Ĥ are based on simulating halt deciders. > I questioned your > repeated assertion that if you don't have fully operational c/x86 code > you have to imagine all the details. You keep asserting that with Turing > Machine you must 'imagine' all the details which is simply false. > > André > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-18 15:24 -0400 |
| Message-ID | <12r1J.107151$lC6.16042@fx41.iad> |
| In reply to | #39436 |
On 9/18/21 1:08 PM, olcott wrote: > On 9/18/2021 11:52 AM, André G. Isaak wrote: >> On 2021-09-18 10:39, olcott wrote: >>> On 9/18/2021 11:10 AM, André G. Isaak wrote: >>>> On 2021-09-18 09:17, olcott wrote: >>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>> >>>>>>> I either must stick with C/x86 code or write a RASP machine, the >>>>>>> only way that my key insights can possible be fully understood is >>>>>>> to have every single detail as fully operational code such that >>>>>>> we can simply see what it does and thus not merely imagine what >>>>>>> it would do. >>>>>> >>>>>> Why do you insist on continuously repeating this rather ridiculous >>>>>> claim? >>>>>> >>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>> imagine what it would do.' One can see *exactly* what it does. >>>>>> >>>>>> André >>>>>> >>>>> >>>>> When H is defined as a simulating halt decider then H correctly >>>>> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>> >>>> And this statement relates to my post how exactly? >>>> >>>> André >>>> >>>> >>> >>> How can [One can see *exactly* what it does] show that my claim that >>> simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly >>> decide the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ? >> >> I made no claims whatsoever in my post about your H. > > This is exactly what I mean by dishonest dodge AKA the strawman error. > > When we examine the Peter Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ > > there is nothing in the peter Linz text where > [One can see *exactly* what it does] > > when we assume that the Peter Linz H/Ĥ are based on simulating halt > deciders. In the Linz text, we are not given the detail of what the machines do inside for their processing, but we know EXACTLY how they behave at an input/output level. H is given a defined input, a properly encoded version of H^ (<H^>) and is defined to end, based on whatever algorithm is inside H to end at either H.qy or H.qn. He then defines a machine H^ that is based on a nearly exact copy of H, with just a minor change in the qy state to make it non-terminal but loop, and the add a duplication of the input, so H^ can take as an input <H^> and then get to the copy of the code of H with <H^> <H^> on the tape, which is by definition the encoding of the machine H^(<H^>). Since it is identical code with identical input, but the property of being a Computation, if H(<H^>.<H^>) will end at H.qn, then H^ will end at H^.qn (and then halt) and if H ends at H.qy then H^ will get to H^.qy (and then loop forever). Yes, Linz doesn't describe how H is designed to get from H.q0 to H.qn or H.qy, and that is intentional, as that is specified totally by the design of H, and since NOTHING has been assumed about it, no possible H has been excluded from the reasoning. Thus, even your simulating halt decider case fits in his model. Once we know what the provided H will do when given this input, we can see what the machine that this input represents, and if H said it would halt, it loops, and if H says it won't halt, it Halts, thus any answer H gives will be wrong. The only other posibilities is that H never gets to either H.qn or H.qy, in which case it has also failed to give the right answer. Since for any possible behavior of any possible machine H, it can not give the right answer for H^(<H^>) he HAS proven that no H can give the right answer to every machine, as he has provided the counter-example for any machine. > >> I questioned your repeated assertion that if you don't have fully >> operational c/x86 code you have to imagine all the details. You keep >> asserting that with Turing Machine you must 'imagine' all the details >> which is simply false. >> >> André >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-18 14:39 -0500 |
| Message-ID | <caKdncaNf93r3dv8nZ2dnUU7-UfNnZ2d@giganews.com> |
| In reply to | #39444 |
On 9/18/2021 2:24 PM, Richard Damon wrote: > On 9/18/21 1:08 PM, olcott wrote: >> On 9/18/2021 11:52 AM, André G. Isaak wrote: >>> On 2021-09-18 10:39, olcott wrote: >>>> On 9/18/2021 11:10 AM, André G. Isaak wrote: >>>>> On 2021-09-18 09:17, olcott wrote: >>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>> >>>>>>>> I either must stick with C/x86 code or write a RASP machine, the >>>>>>>> only way that my key insights can possible be fully understood is >>>>>>>> to have every single detail as fully operational code such that >>>>>>>> we can simply see what it does and thus not merely imagine what >>>>>>>> it would do. >>>>>>> >>>>>>> Why do you insist on continuously repeating this rather ridiculous >>>>>>> claim? >>>>>>> >>>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>>> imagine what it would do.' One can see *exactly* what it does. >>>>>>> >>>>>>> André >>>>>>> >>>>>> >>>>>> When H is defined as a simulating halt decider then H correctly >>>>>> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>> >>>>> And this statement relates to my post how exactly? >>>>> >>>>> André >>>>> >>>>> >>>> >>>> How can [One can see *exactly* what it does] show that my claim that >>>> simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly >>>> decide the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ? >>> >>> I made no claims whatsoever in my post about your H. >> >> This is exactly what I mean by dishonest dodge AKA the strawman error. >> >> When we examine the Peter Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ >> >> there is nothing in the peter Linz text where >> [One can see *exactly* what it does] >> >> when we assume that the Peter Linz H/Ĥ are based on simulating halt >> deciders. > > In the Linz text, we are not given the detail of what the machines do > inside for their processing, but we know EXACTLY how they behave at an > input/output level. > > H is given a defined input, a properly encoded version of H^ (<H^>) > > and is defined to end, based on whatever algorithm is inside H to end at > either H.qy or H.qn. > > He then defines a machine H^ that is based on a nearly exact copy of H, > with just a minor change in the qy state to make it non-terminal but > loop, and the add a duplication of the input, so H^ can take as an input > <H^> and then get to the copy of the code of H with <H^> <H^> on the > tape, which is by definition the encoding of the machine H^(<H^>). > > Since it is identical code with identical input, but the property of > being a Computation, if H(<H^>.<H^>) will end at H.qn, then H^ will end > at H^.qn (and then halt) and if H ends at H.qy then H^ will get to H^.qy > (and then loop forever). > > Yes, Linz doesn't describe how H is designed to get from H.q0 to H.qn or > H.qy, and that is intentional, as that is specified totally by the > design of H, and since NOTHING has been assumed about it, no possible H > has been excluded from the reasoning. > > Thus, even your simulating halt decider case fits in his model. > > Once we know what the provided H will do when given this input, we can > see what the machine that this input represents, and if H said it would > halt, it loops, and if H says it won't halt, it Halts, thus any answer H > gives will be wrong. > > The only other posibilities is that H never gets to either H.qn or H.qy, > in which case it has also failed to give the right answer. > That is factually incorrect. H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly transitions to H.qy. The Linz text does cannot possibly get into sufficient detail to show how this is not true simply because it is true. > Since for any possible behavior of any possible machine H, it can not > give the right answer for H^(<H^>) he HAS proven that no H can give the > right answer to every machine, as he has provided the counter-example > for any machine. > >> >>> I questioned your repeated assertion that if you don't have fully >>> operational c/x86 code you have to imagine all the details. You keep >>> asserting that with Turing Machine you must 'imagine' all the details >>> which is simply false. >>> >>> André >>> >> >> > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-18 15:57 -0400 |
| Message-ID | <axr1J.55095$jm6.40535@fx07.iad> |
| In reply to | #39447 |
On 9/18/21 3:39 PM, olcott wrote: > On 9/18/2021 2:24 PM, Richard Damon wrote: >> On 9/18/21 1:08 PM, olcott wrote: >>> On 9/18/2021 11:52 AM, André G. Isaak wrote: >>>> On 2021-09-18 10:39, olcott wrote: >>>>> On 9/18/2021 11:10 AM, André G. Isaak wrote: >>>>>> On 2021-09-18 09:17, olcott wrote: >>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>> >>>>>>>>> I either must stick with C/x86 code or write a RASP machine, the >>>>>>>>> only way that my key insights can possible be fully understood is >>>>>>>>> to have every single detail as fully operational code such that >>>>>>>>> we can simply see what it does and thus not merely imagine what >>>>>>>>> it would do. >>>>>>>> >>>>>>>> Why do you insist on continuously repeating this rather ridiculous >>>>>>>> claim? >>>>>>>> >>>>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>>>> imagine what it would do.' One can see *exactly* what it does. >>>>>>>> >>>>>>>> André >>>>>>>> >>>>>>> >>>>>>> When H is defined as a simulating halt decider then H correctly >>>>>>> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>> >>>>>> And this statement relates to my post how exactly? >>>>>> >>>>>> André >>>>>> >>>>>> >>>>> >>>>> How can [One can see *exactly* what it does] show that my claim that >>>>> simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly >>>>> decide the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ? >>>> >>>> I made no claims whatsoever in my post about your H. >>> >>> This is exactly what I mean by dishonest dodge AKA the strawman error. >>> >>> When we examine the Peter Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ >>> >>> there is nothing in the peter Linz text where >>> [One can see *exactly* what it does] >>> >>> when we assume that the Peter Linz H/Ĥ are based on simulating halt >>> deciders. >> >> In the Linz text, we are not given the detail of what the machines do >> inside for their processing, but we know EXACTLY how they behave at an >> input/output level. >> >> H is given a defined input, a properly encoded version of H^ (<H^>) >> >> and is defined to end, based on whatever algorithm is inside H to end at >> either H.qy or H.qn. >> >> He then defines a machine H^ that is based on a nearly exact copy of H, >> with just a minor change in the qy state to make it non-terminal but >> loop, and the add a duplication of the input, so H^ can take as an input >> <H^> and then get to the copy of the code of H with <H^> <H^> on the >> tape, which is by definition the encoding of the machine H^(<H^>). >> >> Since it is identical code with identical input, but the property of >> being a Computation, if H(<H^>.<H^>) will end at H.qn, then H^ will end >> at H^.qn (and then halt) and if H ends at H.qy then H^ will get to H^.qy >> (and then loop forever). >> >> Yes, Linz doesn't describe how H is designed to get from H.q0 to H.qn or >> H.qy, and that is intentional, as that is specified totally by the >> design of H, and since NOTHING has been assumed about it, no possible H >> has been excluded from the reasoning. >> >> Thus, even your simulating halt decider case fits in his model. >> >> Once we know what the provided H will do when given this input, we can >> see what the machine that this input represents, and if H said it would >> halt, it loops, and if H says it won't halt, it Halts, thus any answer H >> gives will be wrong. >> >> The only other posibilities is that H never gets to either H.qn or H.qy, >> in which case it has also failed to give the right answer. >> > > That is factually incorrect. > H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly transitions to H.qy. When did you ever claim that H (not H1) ever said that H^(H^) was halting. You can't use H1, as H^ is built on H, if you want to use H1, you need to build the H1^ that calls it to test. Maybe you still don't know what that line means. > > The Linz text does cannot possibly get into sufficient detail to show > how this is not true simply because it is true. > Since your described algorithm for H says that H will declare this input to be non-halting, you are lying to say that this H goes to the terminal state qy. The actual behavior of machine H is determined by the algorithm embedded in it. That algorithm says that <H^> <H^> represents a non-halting computation, therefore H will go to H.qn. Linz says that the H that gives the RIGHT answer for an input that is Halting will go to H.qy, but your H doesn't go there because it is not right. 'Give the right answer' is NOT a valid algorithm for a Turing Machine. > >> Since for any possible behavior of any possible machine H, it can not >> give the right answer for H^(<H^>) he HAS proven that no H can give the >> right answer to every machine, as he has provided the counter-example >> for any machine. >> >>> >>>> I questioned your repeated assertion that if you don't have fully >>>> operational c/x86 code you have to imagine all the details. You keep >>>> asserting that with Turing Machine you must 'imagine' all the details >>>> which is simply false. >>>> >>>> André >>>> >>> >>> >> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-18 15:17 -0500 |
| Message-ID | <4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com> |
| In reply to | #39452 |
On 9/18/2021 2:57 PM, Richard Damon wrote: > On 9/18/21 3:39 PM, olcott wrote: >> On 9/18/2021 2:24 PM, Richard Damon wrote: >>> On 9/18/21 1:08 PM, olcott wrote: >>>> On 9/18/2021 11:52 AM, André G. Isaak wrote: >>>>> On 2021-09-18 10:39, olcott wrote: >>>>>> On 9/18/2021 11:10 AM, André G. Isaak wrote: >>>>>>> On 2021-09-18 09:17, olcott wrote: >>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote: >>>>>>>>> On 2021-09-18 07:57, olcott wrote: >>>>>>>>> >>>>>>>>>> I either must stick with C/x86 code or write a RASP machine, the >>>>>>>>>> only way that my key insights can possible be fully understood is >>>>>>>>>> to have every single detail as fully operational code such that >>>>>>>>>> we can simply see what it does and thus not merely imagine what >>>>>>>>>> it would do. >>>>>>>>> >>>>>>>>> Why do you insist on continuously repeating this rather ridiculous >>>>>>>>> claim? >>>>>>>>> >>>>>>>>> When working with Turing Machines one doesn't need to 'merely >>>>>>>>> imagine what it would do.' One can see *exactly* what it does. >>>>>>>>> >>>>>>>>> André >>>>>>>>> >>>>>>>> >>>>>>>> When H is defined as a simulating halt decider then H correctly >>>>>>>> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>> >>>>>>> And this statement relates to my post how exactly? >>>>>>> >>>>>>> André >>>>>>> >>>>>>> >>>>>> >>>>>> How can [One can see *exactly* what it does] show that my claim that >>>>>> simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly >>>>>> decide the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ? >>>>> >>>>> I made no claims whatsoever in my post about your H. >>>> >>>> This is exactly what I mean by dishonest dodge AKA the strawman error. >>>> >>>> When we examine the Peter Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ >>>> >>>> there is nothing in the peter Linz text where >>>> [One can see *exactly* what it does] >>>> >>>> when we assume that the Peter Linz H/Ĥ are based on simulating halt >>>> deciders. >>> >>> In the Linz text, we are not given the detail of what the machines do >>> inside for their processing, but we know EXACTLY how they behave at an >>> input/output level. >>> >>> H is given a defined input, a properly encoded version of H^ (<H^>) >>> >>> and is defined to end, based on whatever algorithm is inside H to end at >>> either H.qy or H.qn. >>> >>> He then defines a machine H^ that is based on a nearly exact copy of H, >>> with just a minor change in the qy state to make it non-terminal but >>> loop, and the add a duplication of the input, so H^ can take as an input >>> <H^> and then get to the copy of the code of H with <H^> <H^> on the >>> tape, which is by definition the encoding of the machine H^(<H^>). >>> >>> Since it is identical code with identical input, but the property of >>> being a Computation, if H(<H^>.<H^>) will end at H.qn, then H^ will end >>> at H^.qn (and then halt) and if H ends at H.qy then H^ will get to H^.qy >>> (and then loop forever). >>> >>> Yes, Linz doesn't describe how H is designed to get from H.q0 to H.qn or >>> H.qy, and that is intentional, as that is specified totally by the >>> design of H, and since NOTHING has been assumed about it, no possible H >>> has been excluded from the reasoning. >>> >>> Thus, even your simulating halt decider case fits in his model. >>> >>> Once we know what the provided H will do when given this input, we can >>> see what the machine that this input represents, and if H said it would >>> halt, it loops, and if H says it won't halt, it Halts, thus any answer H >>> gives will be wrong. >>> >>> The only other posibilities is that H never gets to either H.qn or H.qy, >>> in which case it has also failed to give the right answer. >>> >> >> That is factually incorrect. >> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly transitions to H.qy. > > When did you ever claim that H (not H1) ever said that H^(H^) was halting. > > You can't use H1, as H^ is built on H, if you want to use H1, you need > to build the H1^ that calls it to test. > > Maybe you still don't know what that line means. > >> >> The Linz text does cannot possibly get into sufficient detail to show >> how this is not true simply because it is true. >> > > Since your described algorithm for H says that H will declare this input > to be non-halting, you are lying to say that this H goes to the terminal > state qy. > > The actual behavior of machine H is determined by the algorithm embedded > in it. That algorithm says that <H^> <H^> represents a non-halting > computation, therefore H will go to H.qn. > > Linz says that the H that gives the RIGHT answer for an input that is > Halting will go to H.qy, but your H doesn't go there because it is not > right. > > 'Give the right answer' is NOT a valid algorithm for a Turing Machine. > When I refer to H1/H I am referring to my C/x86 code. When I refer to H/Ĥ I am referring to the Peter Linz templates. You can't seem to keep this straight. >> >>> Since for any possible behavior of any possible machine H, it can not >>> give the right answer for H^(<H^>) he HAS proven that no H can give the >>> right answer to every machine, as he has provided the counter-example >>> for any machine. >>> >>>> >>>>> I questioned your repeated assertion that if you don't have fully >>>>> operational c/x86 code you have to imagine all the details. You keep >>>>> asserting that with Turing Machine you must 'imagine' all the details >>>>> which is simply false. >>>>> >>>>> André >>>>> >>>> >>>> >>> >> >> > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 4 of 13 — ← Prev page 1 2 3 [4] 5 6 … 13 Next page →
Back to top | Article view | comp.theory
csiph-web