Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #28957 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-03-09 16:56 -0600 |
| Last post | 2021-03-15 02:37 +0000 |
| Articles | 20 on this page of 452 — 20 participants |
Back to article view | Back to comp.theory
Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 16:56 -0600
Re: Refuting the halting problem proofs with fully operational code Siri Cruise <chine.bleu@yahoo.com> - 2021-03-09 15:39 -0800
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 18:49 -0500
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 18:02 -0600
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:35 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 20:49 -0600
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 22:10 -0500
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 21:12 -0600
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:27 +0000
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-10 00:29 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 18:42 -0600
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-10 00:57 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 19:05 -0600
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-10 01:49 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 20:39 -0600
Re: Refuting the halting problem proofs with fully operational code Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-09 18:48 -0800
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 22:18 -0500
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 03:39 +0000
Re: Refuting the halting problem proofs with fully operational code Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-10 03:59 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-09 22:04 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-09 22:20 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-09 20:36 -0800
Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 05:06 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-10 00:12 -0800
Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:23 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:27 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-10 15:41 +0000
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 09:55 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 08:46 -0700
Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 10:12 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 09:55 -0700
Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 16:03 +0000
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 10:23 -0600
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 17:16 +0000
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 12:01 -0600
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 12:11 -0600
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 12:14 -0700
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 14:05 -0600
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-10 22:02 +0000
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 15:08 -0700
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 16:38 -0600
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 15:53 -0700
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 17:07 -0600
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-10 23:40 +0000
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-10 17:10 -0600
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:16 -0500
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) olcott <NoOne@NoWhere.com> - 2021-03-13 15:37 -0600
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 15:18 -0400
Re: Refuting the halting problem proofs with fully operational code (Curry:1977) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 14:16 -0500
Re: Refuting the halting problem proofs with fully operational code (truth) Jeff Barnett <jbb@notatt.com> - 2021-03-10 11:49 -0700
Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 14:20 -0500
Re: Refuting the halting problem proofs with fully operational code (truth) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-10 20:18 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 23:51 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-11 00:38 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) Jeff Barnett <jbb@notatt.com> - 2021-03-10 15:39 -0700
Re: Refuting the halting problem proofs with fully operational code (truth) Peter <peterxpercival@hotmail.com> - 2021-03-12 18:25 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 19:05 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 15:29 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:40 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 19:26 -0500
Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 19:04 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 23:23 -0500
Re: Refuting the halting problem proofs with fully operational code [truth bearer defined] olcott <NoOne@NoWhere.com> - 2021-03-10 22:35 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 16:06 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 14:46 -0400
Re: Refuting the halting problem proofs with fully operational code (truth) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-10 15:25 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:38 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 15:42 +0000
Re: Refuting the halting problem proofs with fully operational code (truth) olcott <NoOne@NoWhere.com> - 2021-03-10 09:56 -0600
Re: Refuting the halting problem proofs with fully operational code (truth) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 11:33 -0500
Re: Refuting the halting problem proofs with fully operational code Daniel Pehoushek <pehoushek1@gmail.com> - 2021-03-09 20:11 -0800
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-11 01:45 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-10 20:10 -0600
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 00:03 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 18:08 -0600
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-14 15:20 -0400
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 08:15 -0600
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 08:31 -0600
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 00:15 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 18:22 -0600
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 01:02 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 20:35 -0600
Re: Refuting the halting problem proofs with fully operational code André G. Isaak <agisaak@gm.invalid> - 2021-03-11 19:36 -0700
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 20:48 -0600
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-11 20:13 -0700
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 21:22 -0600
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-11 21:16 -0700
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 22:24 -0600
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-11 22:20 -0700
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 23:36 -0600
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:38 -0500
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 05:40 +0000
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 08:27 -0600
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 15:28 +0000
Re: Refuting the halting problem proofs with fully operational code [Self-contradictory inputs] Richard Damon <Richard@Damon-Family.org> - 2021-03-11 22:38 -0500
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:35 -0500
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 00:06 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 18:14 -0600
Re: Refuting the halting problem proofs with fully operational code Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 01:06 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 20:43 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 03:29 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-11 21:37 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 05:38 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 08:20 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 15:20 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 09:36 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 16:03 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 10:55 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 17:50 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 12:02 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 18:13 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 12:21 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-12 11:20 -0700
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 12:23 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 19:03 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 13:10 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-12 12:42 -0700
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 13:45 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 16:17 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-12 15:31 -0700
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-12 16:42 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-13 09:00 -0700
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-13 10:29 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-13 08:45 -0800
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-13 10:58 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-13 10:28 -0700
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-13 11:55 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-13 11:25 -0700
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] olcott <NoOne@NoWhere.com> - 2021-03-13 12:38 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] André G. Isaak <agisaak@gm.invalid> - 2021-03-13 12:51 -0700
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Richard Damon <Richard@Damon-Family.org> - 2021-03-14 16:00 -0400
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-12 16:39 -0800
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Richard Damon <Richard@Damon-Family.org> - 2021-03-12 23:20 -0500
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-13 00:34 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-12 20:10 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-13 04:08 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-12 22:51 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-13 23:53 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <polcott2@gmail.com> - 2021-03-13 18:20 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 21:54 -0500
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-14 16:34 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <polcott2@gmail.com> - 2021-03-14 13:17 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 13:27 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-03-14 11:35 -0700
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 13:43 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 17:43 -0400
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-14 18:43 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 14:05 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-14 19:22 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 14:47 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-14 21:22 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 16:46 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 00:00 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 19:43 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 01:12 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 20:24 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 21:50 -0400
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) R Kym Horsell <kym@kymhorsell.com> - 2021-03-15 01:53 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 21:20 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-14 19:29 -0700
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) R Kym Horsell <kym@kymhorsell.com> - 2021-03-15 03:30 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Jeff Barnett <jbb@notatt.com> - 2021-03-15 10:48 -0600
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-14 19:30 -0700
Re: Refuting the halting problem proofs [...]. Andy Walker <anw@cuboid.co.uk> - 2021-03-15 13:38 +0000
Re: Refuting the halting problem proofs [...]. olcott <NoOne@NoWhere.com> - 2021-03-15 09:03 -0500
Re: Refuting the halting problem proofs [...]. Alan Mackenzie <acm@muc.de> - 2021-03-15 14:22 +0000
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-15 09:44 -0500
Re: Refuting the halting problem proofs [...]. Richard Damon <Richard@Damon-Family.org> - 2021-03-16 07:33 -0400
Re: Refuting the halting problem proofs [...]. olcott <NoOne@NoWhere.com> - 2021-03-16 08:32 -0500
Re: Refuting the halting problem proofs [...]. Richard Damon <Richard@Damon-Family.org> - 2021-03-18 23:11 -0400
Re: Refuting the halting problem proofs [...]. olcott <NoOne@NoWhere.com> - 2021-03-18 22:15 -0500
Re: Refuting the halting problem proofs [...]. Richard Damon <Richard@Damon-Family.org> - 2021-03-18 23:50 -0400
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-15 09:09 -0500
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) David Brown <david.brown@hesbynett.no> - 2021-03-15 15:55 +0100
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-15 10:11 -0500
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) David Brown <david.brown@hesbynett.no> - 2021-03-15 16:38 +0100
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-15 12:01 -0500
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) David Brown <david.brown@hesbynett.no> - 2021-03-15 18:53 +0100
Re: Refuting the halting problem proofs [...]. (rebuttal has no basis) olcott <NoOne@NoWhere.com> - 2021-03-15 13:04 -0500
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) Jeff Barnett <jbb@notatt.com> - 2021-03-15 15:15 -0600
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) David Brown <david.brown@hesbynett.no> - 2021-03-16 09:35 +0100
Re: Refuting the halting problem proofs [...]. (I dare you to find the error) olcott <NoOne@NoWhere.com> - 2021-03-16 08:10 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 02:30 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 22:00 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 03:13 +0000
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) olcott <NoOne@NoWhere.com> - 2021-03-14 22:22 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-15 20:18 +0000
Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it) olcott <NoOne@NoWhere.com> - 2021-03-15 15:41 -0500
Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 13:45 +0000
Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it) olcott <NoOne@NoWhere.com> - 2021-03-16 09:59 -0500
Re: Refuting the halting problem proofs with fully operational code (Kaz is getting it) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 17:26 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 13:09 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 18:38 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:14 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 19:46 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:55 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:11 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 15:21 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:27 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 16:19 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:12 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 13:40 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 19:12 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:18 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-03-16 19:21 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 12:33 -0700
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:49 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:04 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 15:14 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:24 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 19:52 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 14:56 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 15:03 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:20 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 15:27 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:31 +0000
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) olcott <NoOne@NoWhere.com> - 2021-03-16 16:21 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:10 +0000
Re: Refuting the halting problem proofs with fully operational code (subordinate computation) olcott <NoOne@NoWhere.com> - 2021-03-17 09:11 -0500
Re: Refuting the halting problem proofs with fully operational code (It is not that hard.) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 12:17 -0700
Re: Refuting the halting problem proofs with fully operational code (simpler example) olcott <NoOne@NoWhere.com> - 2021-03-16 14:46 -0500
Re: Refuting the halting problem proofs with fully operational code (simpler example) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:10 +0000
Re: Refuting the halting problem proofs with fully operational code (simpler example) olcott <NoOne@NoWhere.com> - 2021-03-16 15:17 -0500
Re: Refuting the halting problem proofs with fully operational code (simpler example) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-16 20:22 +0000
Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 16:16 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing computable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 14:38 -0700
Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 16:52 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing computable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 15:25 -0700
Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 17:38 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing computable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 16:03 -0700
Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 18:34 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 18:35 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing computable) Jeff Barnett <jbb@notatt.com> - 2021-03-16 18:01 -0600
Re: Refuting the halting problem proofs with fully operational code (Turing computable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:18 +0000
Re: Refuting the halting problem proofs with fully operational code (Turing computable) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-16 23:42 -0700
Re: Refuting the halting problem proofs with fully operational code (Turing computable) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-16 17:06 -0700
Re: Refuting the halting problem proofs with fully operational code (Turing computable) olcott <NoOne@NoWhere.com> - 2021-03-16 19:22 -0500
Halt Decider "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-03-16 18:29 -0700
Re: Halt Decider olcott <NoOne@NoWhere.com> - 2021-03-16 20:41 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing computable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:17 +0000
Re: Refuting the halting problem proofs with fully operational code (Turing computable) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-17 02:16 +0000
Re: Refuting the halting problem proofs with fully operational code (Turing computable)[unconventional part] olcott <NoOne@NoWhere.com> - 2021-03-17 09:27 -0500
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 21:47 -0400
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 20:14 -0400
Re: Refuting the halting problem proofs with fully operational code (argument reframed on Ben's suggestion) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 20:09 -0400
Re: Refuting the halting problem proofs [...] Andy Walker <anw@cuboid.co.uk> - 2021-03-13 12:18 +0000
Re: Refuting the halting problem proofs [...](contradictory questions) olcott <NoOne@NoWhere.com> - 2021-03-13 08:18 -0600
Re: Refuting the halting problem proofs [...] (contradictory questions) olcott <NoOne@NoWhere.com> - 2021-03-13 08:23 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-14 02:10 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-13 20:21 -0600
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 21:59 -0500
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 02:30 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-14 22:15 -0500
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 03:33 +0000
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) olcott <NoOne@NoWhere.com> - 2021-03-14 22:40 -0500
Re: Refuting the halting problem proofs with fully operational code [self-contradictory inputs](Jack's question) Richard Damon <Richard@Damon-Family.org> - 2021-03-15 08:25 -0400
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-11 22:51 -0500
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-11 22:08 -0600
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-13 12:39 -0500
Re: Refuting the halting problem proofs with fully operational code (switch statement not relevant) olcott <NoOne@NoWhere.com> - 2021-03-13 12:01 -0600
Re: Refuting the halting problem proofs with fully operational code (switch statement not relevant) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:56 -0500
Re: Refuting the halting problem proofs with fully operational code André G. Isaak <agisaak@gm.invalid> - 2021-03-13 11:01 -0700
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-13 12:33 -0600
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:55 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 21:07 -0600
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 03:34 +0000
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 22:16 -0500
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 02:47 +0000
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 20:55 -0600
Re: Refuting the halting problem proofs with fully operational code Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 03:27 +0000
Re: Refuting the halting problem proofs with fully operational code André G. Isaak <agisaak@gm.invalid> - 2021-03-09 20:38 -0700
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-09 21:42 -0600
Re: Refuting the halting problem proofs with fully operational code André G. Isaak <agisaak@gm.invalid> - 2021-03-09 21:24 -0700
Re: Refuting the halting problem proofs with fully operational code (UTM decider) olcott <NoOne@NoWhere.com> - 2021-03-09 22:30 -0600
Re: Refuting the halting problem proofs with fully operational code (UTM decider) André G. Isaak <agisaak@gm.invalid> - 2021-03-09 21:58 -0700
Re: Refuting the halting problem proofs with fully operational code (UTM decider) olcott <NoOne@NoWhere.com> - 2021-03-10 09:19 -0600
Re: Refuting the halting problem proofs with fully operational code (UTM decider) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 08:43 -0700
Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 10:03 -0600
Re: Refuting the halting problem proofs with fully operational code (one point at a time) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 09:33 -0700
Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 11:35 -0600
Re: Refuting the halting problem proofs with fully operational code (one point at a time) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 10:57 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 12:09 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 12:09 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 14:01 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 13:36 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 15:01 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 14:13 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 16:23 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 15:48 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 17:01 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 16:58 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 18:34 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 17:45 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 19:05 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-10 20:36 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 21:40 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 23:49 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 17:57 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 00:18 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 19:01 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 02:43 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 20:53 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 03:04 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 21:24 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 23:51 -0500
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-10 23:12 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 09:43 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 11:13 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 11:23 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 11:47 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 13:00 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 12:23 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 13:41 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:04 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:22 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-12 00:07 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:00 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:20 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:56 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 10:38 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 11:50 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 18:54 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 13:03 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 12:44 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 13:50 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 13:34 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-11 12:42 -0800
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:01 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) André G. Isaak <agisaak@gm.invalid> - 2021-03-11 14:12 -0700
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:26 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:54 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:52 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:46 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-11 23:41 +0000
Re: Refuting the halting problem proofs with fully operational code (tedious distinction) olcott <NoOne@NoWhere.com> - 2021-03-11 17:56 -0600
Re: Refuting the halting problem proofs with fully operational code (tedious distinction) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-12 00:52 +0000
Re: Refuting the halting problem proofs with fully operational code (tedious distinction) olcott <NoOne@NoWhere.com> - 2021-03-11 19:10 -0600
Re: Refuting the halting problem proofs with fully operational code (tedious distinction) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-13 00:21 +0000
Re: Refuting the halting problem proofs with fully operational code (tedious distinction) olcott <NoOne@NoWhere.com> - 2021-03-12 19:57 -0600
Re: Refuting the halting problem proofs with fully operational code (tedious distinction) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 16:59 -0500
Re: Refuting the halting problem proofs with fully operational code (tedious distinction) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-14 01:50 +0000
Re: Refuting the halting problem proofs with fully operational code (tedious distinction) olcott <NoOne@NoWhere.com> - 2021-03-13 20:07 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 20:52 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) olcott <NoOne@NoWhere.com> - 2021-03-11 15:15 -0600
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 21:56 +0000
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Richard Damon <Richard@Damon-Family.org> - 2021-03-11 23:11 -0500
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Richard Damon <Richard@Damon-Family.org> - 2021-03-11 23:05 -0500
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-10 20:39 -0800
Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 19:41 -0500
Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 14:03 -0500
Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 13:08 -0600
Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 15:05 -0500
Re: Refuting the halting problem proofs with fully operational code (one point at a time) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 21:16 +0000
Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 16:26 -0600
Re: Refuting the halting problem proofs with fully operational code (one point at a time) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-11 00:28 +0000
Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-10 19:07 -0600
Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-11 08:29 -0500
Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-11 07:45 -0600
Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-11 21:52 -0500
Re: Refuting the halting problem proofs with fully operational code (one point at a time) olcott <NoOne@NoWhere.com> - 2021-03-11 21:01 -0600
Re: Refuting the halting problem proofs with fully operational code (one point at a time) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 19:29 -0500
Re: Refuting the halting problem proofs with fully operational code (UTM decider) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 05:04 +0000
Re: Refuting the halting problem proofs with fully operational code (UTM decider) olcott <NoOne@NoWhere.com> - 2021-03-10 09:21 -0600
Re: Refuting the halting problem proofs with fully operational code (UTM decider) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 15:33 +0000
Re: Refuting the halting problem proofs with fully operational code (UTM decider) olcott <NoOne@NoWhere.com> - 2021-03-10 09:45 -0600
Re: Refuting the halting problem proofs with fully operational code (UTM decider) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-10 16:10 +0000
Re: Refuting the halting problem proofs with fully operational code (UTM decider) Richard Damon <Richard@Damon-Family.org> - 2021-03-10 11:45 -0500
Re: Refuting the halting problem proofs with fully operational code Richard Damon <Richard@Damon-Family.org> - 2021-03-09 22:14 -0500
Re: Refuting the halting problem proofs with fully operational code "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-10 17:49 -0800
Re: Refuting the halting problem proofs with fully operational code Bonita Montero <Bonita.Montero@gmail.com> - 2021-03-13 16:19 +0100
Re: Refuting the halting problem proofs with fully operational code olcott <NoOne@NoWhere.com> - 2021-03-13 14:39 -0600
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 14:49 -0600
Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-13 13:38 -0800
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 15:51 -0600
Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-13 14:00 -0800
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 16:05 -0600
Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 21:07 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-14 03:29 -0700
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <polcott2@gmail.com> - 2021-03-14 09:55 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-14 10:25 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 16:08 -0400
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 15:13 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) André G. Isaak <agisaak@gm.invalid> - 2021-03-14 14:44 -0600
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 16:02 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 16:06 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-14 23:58 +0000
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 19:27 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 03:15 +0000
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 22:24 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 03:39 +0000
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 22:43 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Richard Damon <Richard@Damon-Family.org> - 2021-03-15 08:30 -0400
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) R Kym Horsell <kym@kymhorsell.com> - 2021-03-15 03:27 +0000
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 12:51 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 15:20 -0500
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 14:54 -0600
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 16:29 -0500
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 15:33 -0600
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 17:00 -0500
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 18:59 -0600
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 20:34 -0500
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 20:53 -0600
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 22:22 -0500
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] André G. Isaak <agisaak@gm.invalid> - 2021-03-15 22:10 -0600
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] Richard Damon <Richard@Damon-Family.org> - 2021-03-16 08:04 -0400
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 14:33 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 16:56 -0500
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 15:01 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 15:04 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 15:11 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 17:28 -0500
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 16:01 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 20:47 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <NoOne@NoWhere.com> - 2021-03-15 22:58 -0500
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 21:36 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 21:39 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] olcott <polcott2@gmail.com> - 2021-03-16 00:00 -0500
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 22:08 -0700
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] Richard Damon <Richard@Damon-Family.org> - 2021-03-16 08:05 -0400
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] Richard Damon <Richard@Damon-Family.org> - 2021-03-16 08:18 -0400
Re: Refuting the halting problem proofs with fully operational code [bloody idiots] "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-16 23:39 -0700
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) André G. Isaak <agisaak@gm.invalid> - 2021-03-14 15:09 -0600
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 16:12 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) André G. Isaak <agisaak@gm.invalid> - 2021-03-14 15:54 -0600
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 17:18 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) André G. Isaak <agisaak@gm.invalid> - 2021-03-14 17:02 -0600
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 20:31 -0400
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) olcott <NoOne@NoWhere.com> - 2021-03-14 17:43 -0500
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 18:01 -0400
Re: Refuting the halting problem proofs with fully operational code (Turing equivalence) Richard Damon <Richard@Damon-Family.org> - 2021-03-14 17:55 -0400
Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-14 17:38 -0700
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-14 19:54 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-15 03:05 -0700
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-15 08:09 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-15 13:37 -0700
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-15 15:52 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-15 14:09 -0700
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-15 16:22 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-15 14:37 -0700
Re: Refuting the halting problem proofs with fully operational code (revised answer) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-14 02:26 +0000
Re: Refuting the halting problem proofs with fully operational code (is Ben's non-halting criteria correct?) olcott <polcott2@gmail.com> - 2021-03-13 20:53 -0600
Re: Refuting the halting problem proofs with fully operational code (is Ben's non-halting criteria correct?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 03:07 +0000
Re: Refuting the halting problem proofs with fully operational code (is Ben's non-halting criteria correct?) olcott <NoOne@NoWhere.com> - 2021-03-14 22:32 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 16:09 -0600
Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 17:02 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) André G. Isaak <agisaak@gm.invalid> - 2021-03-13 16:05 -0700
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <NoOne@NoWhere.com> - 2021-03-13 17:33 -0600
Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 21:09 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-14 02:10 +0000
Re: Refuting the halting problem proofs with fully operational code (revised answer) olcott <polcott2@gmail.com> - 2021-03-13 20:30 -0600
Re: Refuting the halting problem proofs with fully operational code (revised answer) Richard Damon <Richard@Damon-Family.org> - 2021-03-13 22:06 -0500
Re: Refuting the halting problem proofs with fully operational code (revised answer) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-15 02:37 +0000
Page 17 of 23 — ← Prev page 1 … 15 16 [17] 18 19 … 23 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-11 11:50 -0600 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <K5idnQ3n7-Lhxdf9nZ2dnUU78L_NnZ2d@giganews.com> |
| In reply to | #29110 |
On 3/11/2021 11:38 AM, André G. Isaak wrote: > On 2021-03-11 10:13, olcott wrote: > >> I did have to correct your syntax and create Simulate2() that takes >> three params, Simulate() only takes two params. >> >> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat ); >> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat ); > > > If you're trying to make an actual simulator, you would ideally use > stdarg and declare it as having a variable argument list. > > André > In my case this would simply make my object code unnecessarily more complex. https://en.wikipedia.org/wiki/Variadic_function#In_C I must make the object code as simple as possible so that people can see all of the details of the halt decider's basis. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-03-11 18:54 +0000 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <20210311102222.343@kylheku.com> |
| In reply to | #29108 |
On 2021-03-11, olcott <NoOne@NoWhere.com> wrote:
> On 3/11/2021 10:43 AM, André G. Isaak wrote:
>> On 2021-03-10 22:12, olcott wrote:
>>> On 3/10/2021 10:51 PM, Richard Damon wrote:
>>>> On 3/10/21 10:24 PM, olcott wrote:
>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote:
>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote:
>>>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote:
>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion in your
>>>>>>>>>> system,
>>>>>>>>>> though! You have an aborting simulator which makes it possible
>>>>>>>>>> for a
>>>>>>>>>> recurring call to the same function with the same arguments to
>>>>>>>>>> terminate after a couple nestings, such that Halts suddenly
>>>>>>>>>> returns
>>>>>>>>>> zero.
>>>>>>>>>
>>>>>>>>> You don't understand the code well enough.
>>>>>>>>> Returing 0 does not stop the infinite recursion.
>>>>>>>>
>>>>>>>> Returning ... does not stop infinite recursion?
>>>>>>>>
>>>>>>>> What happened to "infinitely recursive calls never, ever, ever
>>>>>>>> return
>>>>>>>> to their callers, you ignorant jackasses?"
>>>>>>>>
>>>>>>>> ROFL
>>>>>>>>
>>>>>>>
>>>>>>> That is exactly what I mean:
>>>>>>> -"infinitely recursive calls never, ever, ever return
>>>>>>> -to their callers, you ignorant jackasses!"
>>>>>>>
>>>>>>> When Halts() simply simulates its input and returns 0 when it is done
>>>>>>
>>>>>> Right, but Halts /doesn't/ simply simulate its input when main asks it
>>>>>> to decide Halts(H_Hat, H_Hat).
>>>>>
>>>>> To prove my point I change the code so that it really does simply
>>>>> simulate its input. When I tell you that it simply simulates its input
>>>>> this is a stipulating definition.
>>
>> You can't 'stipulate' what something does.
>>
>>>>> When a BASIC program contains the statement
>>>>> 100 let X = 5
>>>>> You are not free to disagree that X has the value of 5.
>>>>>
>>>>> Likewise when I say that Halts() simply simulates its input you can
>>>>> know
>>>>> that the code has been changed so that it really does simply simulate
>>>>> its input. That you disagree with basic facts is a really jackass move.
>>>>>
>>>>>
>>>>>
>>>>
>>>> Changing Halts Everywhere, changes the computation being simulated.
>>> Not in a control flow significant way and because you already know
>>> this you are a jackass for implying that it does.
>>
>> Here is a critical test for you. If your Simulate() *really* does
>> accurately simulate its input, then the following two ought to behave
>> differently:
>>
>> 1. Simulate(Halts(H_Hat, H_Hat));
>> 2. Simulate(Simulate(H_Hat, H_Hat));
>>
>> André
>>
>
> I haven't finished rewriting the global halt decider so I am not sure
> what it would do.
>
> I did have to correct your syntax and create Simulate2() that takes
> three params, Simulate() only takes two params.
>
> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat );
> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat );
The problem is that you're making a strawman version of the halting
problem.
There is no inherent self-reference in the real problem.
The way that halting can conceptually map onto a real computer is this:
1. The author of the halt decider ("Decider Vendor, V") provides an
*executable* program called halts (/usr/bin/halts, or C:\Program
Files\Halts\halts.exe) or whatever. This works using a published
algorithm.
2. This program takes two arguments, which are paths: one is a program,
another is its input.
3. The attacker ("Decider Attacker, A") will produce a h-hat
executable, such that "halts h-hat h-hat" gets the wrong answer;
halts reports true when "h-hat h-hat" fails to halt, and vice versa.
4. This h-hat executable *DOES NOT WORK BY CALLING halts*. It uses
its own internal copy of the published algorithm.
In short, halts cannot just look for a *call* to itself from h-hat;
that never happens. It has to recognize that h-hat is executing
the same algorithm, and then behaving in the contradictory way.
Recognizing an algorithm is ... an undecidable problem.
This follows from the function equal(x, y) being undecidable
when x and y are functions.
Equal functions are functions which have exactly the same domain, and
calculate exactly the same values from that domain.
Functions can be equal even though their definitions are radically
different. Of course, in the easy case when x and y do have exactly the
same definition, then equal can short-circuit to a true answer; but all
other cases are increasingly difficult.
So that is it in a nuthshell. If you think you have a halting algorithm,
you have to describe that in algorithmic terms. Someone else can take
that algorithm and implement it in any number of ways, and write a H_Hat
around that. That H_Hat will defeat all implementations of that
algorithm, no matter how their implementation details differ.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-11 13:03 -0600 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <uqqdnXGdxfXy9Nf9nZ2dnUU7-bfNnZ2d@giganews.com> |
| In reply to | #29113 |
On 3/11/2021 12:54 PM, Kaz Kylheku wrote: > On 2021-03-11, olcott <NoOne@NoWhere.com> wrote: >> On 3/11/2021 10:43 AM, André G. Isaak wrote: >>> On 2021-03-10 22:12, olcott wrote: >>>> On 3/10/2021 10:51 PM, Richard Damon wrote: >>>>> On 3/10/21 10:24 PM, olcott wrote: >>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote: >>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote: >>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote: >>>>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote: >>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion in your >>>>>>>>>>> system, >>>>>>>>>>> though! You have an aborting simulator which makes it possible >>>>>>>>>>> for a >>>>>>>>>>> recurring call to the same function with the same arguments to >>>>>>>>>>> terminate after a couple nestings, such that Halts suddenly >>>>>>>>>>> returns >>>>>>>>>>> zero. >>>>>>>>>> >>>>>>>>>> You don't understand the code well enough. >>>>>>>>>> Returing 0 does not stop the infinite recursion. >>>>>>>>> >>>>>>>>> Returning ... does not stop infinite recursion? >>>>>>>>> >>>>>>>>> What happened to "infinitely recursive calls never, ever, ever >>>>>>>>> return >>>>>>>>> to their callers, you ignorant jackasses?" >>>>>>>>> >>>>>>>>> ROFL >>>>>>>>> >>>>>>>> >>>>>>>> That is exactly what I mean: >>>>>>>> -"infinitely recursive calls never, ever, ever return >>>>>>>> -to their callers, you ignorant jackasses!" >>>>>>>> >>>>>>>> When Halts() simply simulates its input and returns 0 when it is done >>>>>>> >>>>>>> Right, but Halts /doesn't/ simply simulate its input when main asks it >>>>>>> to decide Halts(H_Hat, H_Hat). >>>>>> >>>>>> To prove my point I change the code so that it really does simply >>>>>> simulate its input. When I tell you that it simply simulates its input >>>>>> this is a stipulating definition. >>> >>> You can't 'stipulate' what something does. >>> >>>>>> When a BASIC program contains the statement >>>>>> 100 let X = 5 >>>>>> You are not free to disagree that X has the value of 5. >>>>>> >>>>>> Likewise when I say that Halts() simply simulates its input you can >>>>>> know >>>>>> that the code has been changed so that it really does simply simulate >>>>>> its input. That you disagree with basic facts is a really jackass move. >>>>>> >>>>>> >>>>>> >>>>> >>>>> Changing Halts Everywhere, changes the computation being simulated. >>>> Not in a control flow significant way and because you already know >>>> this you are a jackass for implying that it does. >>> >>> Here is a critical test for you. If your Simulate() *really* does >>> accurately simulate its input, then the following two ought to behave >>> differently: >>> >>> 1. Simulate(Halts(H_Hat, H_Hat)); >>> 2. Simulate(Simulate(H_Hat, H_Hat)); >>> >>> André >>> >> >> I haven't finished rewriting the global halt decider so I am not sure >> what it would do. >> >> I did have to correct your syntax and create Simulate2() that takes >> three params, Simulate() only takes two params. >> >> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat ); >> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat ); > > The problem is that you're making a strawman version of the halting > problem. > > There is no inherent self-reference in the real problem. So then H_Hat() does not do the opposite of whatever the halt decider decides ABOUT ITS OWN BEHAVIOR ??? -- 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-03-11 12:44 -0700 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <s2drul$vuo$1@dont-email.me> |
| In reply to | #29115 |
On 2021-03-11 12:03, olcott wrote: > On 3/11/2021 12:54 PM, Kaz Kylheku wrote: >> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote: >>> On 3/11/2021 10:43 AM, André G. Isaak wrote: >>>> On 2021-03-10 22:12, olcott wrote: >>>>> On 3/10/2021 10:51 PM, Richard Damon wrote: >>>>>> On 3/10/21 10:24 PM, olcott wrote: >>>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote: >>>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote: >>>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote: >>>>>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote: >>>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion in >>>>>>>>>>>> your >>>>>>>>>>>> system, >>>>>>>>>>>> though! You have an aborting simulator which makes it possible >>>>>>>>>>>> for a >>>>>>>>>>>> recurring call to the same function with the same arguments to >>>>>>>>>>>> terminate after a couple nestings, such that Halts suddenly >>>>>>>>>>>> returns >>>>>>>>>>>> zero. >>>>>>>>>>> >>>>>>>>>>> You don't understand the code well enough. >>>>>>>>>>> Returing 0 does not stop the infinite recursion. >>>>>>>>>> >>>>>>>>>> Returning ... does not stop infinite recursion? >>>>>>>>>> >>>>>>>>>> What happened to "infinitely recursive calls never, ever, ever >>>>>>>>>> return >>>>>>>>>> to their callers, you ignorant jackasses?" >>>>>>>>>> >>>>>>>>>> ROFL >>>>>>>>>> >>>>>>>>> >>>>>>>>> That is exactly what I mean: >>>>>>>>> -"infinitely recursive calls never, ever, ever return >>>>>>>>> -to their callers, you ignorant jackasses!" >>>>>>>>> >>>>>>>>> When Halts() simply simulates its input and returns 0 when it >>>>>>>>> is done >>>>>>>> >>>>>>>> Right, but Halts /doesn't/ simply simulate its input when main >>>>>>>> asks it >>>>>>>> to decide Halts(H_Hat, H_Hat). >>>>>>> >>>>>>> To prove my point I change the code so that it really does simply >>>>>>> simulate its input. When I tell you that it simply simulates its >>>>>>> input >>>>>>> this is a stipulating definition. >>>> >>>> You can't 'stipulate' what something does. >>>> >>>>>>> When a BASIC program contains the statement >>>>>>> 100 let X = 5 >>>>>>> You are not free to disagree that X has the value of 5. >>>>>>> >>>>>>> Likewise when I say that Halts() simply simulates its input you can >>>>>>> know >>>>>>> that the code has been changed so that it really does simply >>>>>>> simulate >>>>>>> its input. That you disagree with basic facts is a really jackass >>>>>>> move. >>>>>>> >>>>>>> >>>>>>> >>>>>> >>>>>> Changing Halts Everywhere, changes the computation being simulated. >>>>> Not in a control flow significant way and because you already know >>>>> this you are a jackass for implying that it does. >>>> >>>> Here is a critical test for you. If your Simulate() *really* does >>>> accurately simulate its input, then the following two ought to behave >>>> differently: >>>> >>>> 1. Simulate(Halts(H_Hat, H_Hat)); >>>> 2. Simulate(Simulate(H_Hat, H_Hat)); >>>> >>>> André >>>> >>> >>> I haven't finished rewriting the global halt decider so I am not sure >>> what it would do. >>> >>> I did have to correct your syntax and create Simulate2() that takes >>> three params, Simulate() only takes two params. >>> >>> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat ); >>> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat ); >> >> The problem is that you're making a strawman version of the halting >> problem. >> >> There is no inherent self-reference in the real problem. > So then H_Hat() does not do the opposite of whatever the halt decider > decides ABOUT ITS OWN BEHAVIOR ??? You're making it sounds as if H_Hat is somehow waiting for the its caller to return an answer and then deviously changing its behaviour after that answer has been delivered (an impossibility). H_Hat has no way of knowing who might be calling it or how that caller might behave. H_Hat may contain state transitions which are based on those of Halts, but H_Hat is an entirely separate program from Halts. Halts isn't being asked to make a decision about itself. It is attempting to make a decision about some independent program called H_Hat. André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-11 13:50 -0600 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <Za2dnWkUcZMZ6df9nZ2dnUU7-R_NnZ2d@giganews.com> |
| In reply to | #29118 |
On 3/11/2021 1:44 PM, André G. Isaak wrote:
> On 2021-03-11 12:03, olcott wrote:
>> On 3/11/2021 12:54 PM, Kaz Kylheku wrote:
>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote:
>>>> On 3/11/2021 10:43 AM, André G. Isaak wrote:
>>>>> On 2021-03-10 22:12, olcott wrote:
>>>>>> On 3/10/2021 10:51 PM, Richard Damon wrote:
>>>>>>> On 3/10/21 10:24 PM, olcott wrote:
>>>>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote:
>>>>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote:
>>>>>>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion in
>>>>>>>>>>>>> your
>>>>>>>>>>>>> system,
>>>>>>>>>>>>> though! You have an aborting simulator which makes it possible
>>>>>>>>>>>>> for a
>>>>>>>>>>>>> recurring call to the same function with the same arguments to
>>>>>>>>>>>>> terminate after a couple nestings, such that Halts suddenly
>>>>>>>>>>>>> returns
>>>>>>>>>>>>> zero.
>>>>>>>>>>>>
>>>>>>>>>>>> You don't understand the code well enough.
>>>>>>>>>>>> Returing 0 does not stop the infinite recursion.
>>>>>>>>>>>
>>>>>>>>>>> Returning ... does not stop infinite recursion?
>>>>>>>>>>>
>>>>>>>>>>> What happened to "infinitely recursive calls never, ever, ever
>>>>>>>>>>> return
>>>>>>>>>>> to their callers, you ignorant jackasses?"
>>>>>>>>>>>
>>>>>>>>>>> ROFL
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That is exactly what I mean:
>>>>>>>>>> -"infinitely recursive calls never, ever, ever return
>>>>>>>>>> -to their callers, you ignorant jackasses!"
>>>>>>>>>>
>>>>>>>>>> When Halts() simply simulates its input and returns 0 when it
>>>>>>>>>> is done
>>>>>>>>>
>>>>>>>>> Right, but Halts /doesn't/ simply simulate its input when main
>>>>>>>>> asks it
>>>>>>>>> to decide Halts(H_Hat, H_Hat).
>>>>>>>>
>>>>>>>> To prove my point I change the code so that it really does simply
>>>>>>>> simulate its input. When I tell you that it simply simulates its
>>>>>>>> input
>>>>>>>> this is a stipulating definition.
>>>>>
>>>>> You can't 'stipulate' what something does.
>>>>>
>>>>>>>> When a BASIC program contains the statement
>>>>>>>> 100 let X = 5
>>>>>>>> You are not free to disagree that X has the value of 5.
>>>>>>>>
>>>>>>>> Likewise when I say that Halts() simply simulates its input you can
>>>>>>>> know
>>>>>>>> that the code has been changed so that it really does simply
>>>>>>>> simulate
>>>>>>>> its input. That you disagree with basic facts is a really
>>>>>>>> jackass move.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Changing Halts Everywhere, changes the computation being simulated.
>>>>>> Not in a control flow significant way and because you already know
>>>>>> this you are a jackass for implying that it does.
>>>>>
>>>>> Here is a critical test for you. If your Simulate() *really* does
>>>>> accurately simulate its input, then the following two ought to behave
>>>>> differently:
>>>>>
>>>>> 1. Simulate(Halts(H_Hat, H_Hat));
>>>>> 2. Simulate(Simulate(H_Hat, H_Hat));
>>>>>
>>>>> André
>>>>>
>>>>
>>>> I haven't finished rewriting the global halt decider so I am not sure
>>>> what it would do.
>>>>
>>>> I did have to correct your syntax and create Simulate2() that takes
>>>> three params, Simulate() only takes two params.
>>>>
>>>> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat );
>>>> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat );
>>>
>>> The problem is that you're making a strawman version of the halting
>>> problem.
>>>
>>> There is no inherent self-reference in the real problem.
>> So then H_Hat() does not do the opposite of whatever the halt decider
>> decides ABOUT ITS OWN BEHAVIOR ???
>
> You're making it sounds as if H_Hat is somehow waiting for the its
> caller to return an answer and then deviously changing its behaviour
> after that answer has been delivered (an impossibility).
It is shown that H_Hat() <is> defined to do the opposite of whatever
value that Halts() returns.
void H_Hat(u32 P)
{
u32 Input_Would_Halt = Halts(P, P);
if (Input_Would_Halt)
HERE: goto HERE;
}
I can't tell that your disagreement with this is dishonest or
incompetent. It seems like you are trying to dishonestly apply the
fallacy of equivocation error so that your weasel wording is mistaken
for truth.
Any question that is defined to contradict every answer is an incorrect
question.
Any decision problem inputs that are defined to contradict both true and
false decisions are incorrect inputs.
When the input program does opposite of whatever the halt decider
decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological
self-reference error.
Removing the pathological self-reference error from the halting problem
derives this corrected halting problem decision criteria:
Would the input program halt if the halt decider never stopped
simulating it?
--
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-03-11 13:34 -0700 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <s2dutg$thj$1@dont-email.me> |
| In reply to | #29119 |
On 2021-03-11 12:50, olcott wrote:
> On 3/11/2021 1:44 PM, André G. Isaak wrote:
>> On 2021-03-11 12:03, olcott wrote:
>>> On 3/11/2021 12:54 PM, Kaz Kylheku wrote:
>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 3/11/2021 10:43 AM, André G. Isaak wrote:
>>>>>> On 2021-03-10 22:12, olcott wrote:
>>>>>>> On 3/10/2021 10:51 PM, Richard Damon wrote:
>>>>>>>> On 3/10/21 10:24 PM, olcott wrote:
>>>>>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote:
>>>>>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote:
>>>>>>>>>>>> On 2021-03-11, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion
>>>>>>>>>>>>>> in your
>>>>>>>>>>>>>> system,
>>>>>>>>>>>>>> though! You have an aborting simulator which makes it
>>>>>>>>>>>>>> possible
>>>>>>>>>>>>>> for a
>>>>>>>>>>>>>> recurring call to the same function with the same
>>>>>>>>>>>>>> arguments to
>>>>>>>>>>>>>> terminate after a couple nestings, such that Halts suddenly
>>>>>>>>>>>>>> returns
>>>>>>>>>>>>>> zero.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You don't understand the code well enough.
>>>>>>>>>>>>> Returing 0 does not stop the infinite recursion.
>>>>>>>>>>>>
>>>>>>>>>>>> Returning ... does not stop infinite recursion?
>>>>>>>>>>>>
>>>>>>>>>>>> What happened to "infinitely recursive calls never, ever, ever
>>>>>>>>>>>> return
>>>>>>>>>>>> to their callers, you ignorant jackasses?"
>>>>>>>>>>>>
>>>>>>>>>>>> ROFL
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That is exactly what I mean:
>>>>>>>>>>> -"infinitely recursive calls never, ever, ever return
>>>>>>>>>>> -to their callers, you ignorant jackasses!"
>>>>>>>>>>>
>>>>>>>>>>> When Halts() simply simulates its input and returns 0 when it
>>>>>>>>>>> is done
>>>>>>>>>>
>>>>>>>>>> Right, but Halts /doesn't/ simply simulate its input when main
>>>>>>>>>> asks it
>>>>>>>>>> to decide Halts(H_Hat, H_Hat).
>>>>>>>>>
>>>>>>>>> To prove my point I change the code so that it really does simply
>>>>>>>>> simulate its input. When I tell you that it simply simulates
>>>>>>>>> its input
>>>>>>>>> this is a stipulating definition.
>>>>>>
>>>>>> You can't 'stipulate' what something does.
>>>>>>
>>>>>>>>> When a BASIC program contains the statement
>>>>>>>>> 100 let X = 5
>>>>>>>>> You are not free to disagree that X has the value of 5.
>>>>>>>>>
>>>>>>>>> Likewise when I say that Halts() simply simulates its input you
>>>>>>>>> can
>>>>>>>>> know
>>>>>>>>> that the code has been changed so that it really does simply
>>>>>>>>> simulate
>>>>>>>>> its input. That you disagree with basic facts is a really
>>>>>>>>> jackass move.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Changing Halts Everywhere, changes the computation being simulated.
>>>>>>> Not in a control flow significant way and because you already know
>>>>>>> this you are a jackass for implying that it does.
>>>>>>
>>>>>> Here is a critical test for you. If your Simulate() *really* does
>>>>>> accurately simulate its input, then the following two ought to behave
>>>>>> differently:
>>>>>>
>>>>>> 1. Simulate(Halts(H_Hat, H_Hat));
>>>>>> 2. Simulate(Simulate(H_Hat, H_Hat));
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> I haven't finished rewriting the global halt decider so I am not sure
>>>>> what it would do.
>>>>>
>>>>> I did have to correct your syntax and create Simulate2() that takes
>>>>> three params, Simulate() only takes two params.
>>>>>
>>>>> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat );
>>>>> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat );
>>>>
>>>> The problem is that you're making a strawman version of the halting
>>>> problem.
>>>>
>>>> There is no inherent self-reference in the real problem.
>>> So then H_Hat() does not do the opposite of whatever the halt decider
>>> decides ABOUT ITS OWN BEHAVIOR ???
>>
>> You're making it sounds as if H_Hat is somehow waiting for the its
>> caller to return an answer and then deviously changing its behaviour
>> after that answer has been delivered (an impossibility).
>
> It is shown that H_Hat() <is> defined to do the opposite of whatever
> value that Halts() returns.
>
> void H_Hat(u32 P)
> {
> u32 Input_Would_Halt = Halts(P, P);
> if (Input_Would_Halt)
> HERE: goto HERE;
> }
>
> I can't tell that your disagreement with this is dishonest or
> incompetent. It seems like you are trying to dishonestly apply the
> fallacy of equivocation error so that your weasel wording is mistaken
> for truth.
>
> Any question that is defined to contradict every answer is an incorrect
> question.
>
> Any decision problem inputs that are defined to contradict both true and
> false decisions are incorrect inputs.
>
> When the input program does opposite of whatever the halt decider
> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological
> self-reference error.
THERE IS NO SELF REFERENCE!
You keep talking about this, but your reference point is a variety of
natural language phenomena which have absolutely no equivalent in the
domain under discussion.
H_Hat is constructed by modifying *a copy* of the state transitions of
Turing Machine H and then appending some additional trasitions. The
result is an entirely separate Turing Machine from H.
When H is run with an input of H_Hat, H_Hat, H does *not* call itself.
Nothing calls itself. There is no notion of 'calling' where TMs are
concerned, let alone the idea of 'calling oneself'.
H_Hat performs a specific computation, albeit one that likely has no
real value.
H purports to be a TM which can answer the question 'does this
computation Halt?' for *any* computation. It does not purport to answer
this question only for computations which were not created in a
particular manner. The entire point of the proof is to show that such an
H is not possible.
> Removing the pathological self-reference error from the halting problem
> derives this corrected halting problem decision criteria:
You have yet to offer a definition for 'self-reference' (pathological or
otherwise) which can meaningfully be applied to Turing Machines (or
math, or logic, or...) rather than natural language. Until you do that,
the above is simply incoherent.
> Would the input program halt if the halt decider never stopped
> simulating it?
Yes, it would. The only sane interpretation of the above is one in which
'halt decider' refers to the outermost invocation of Halts(). Any
subsequent invocations from within H_Hat are not the halt decider since
H_Hat doesn't purport to decide halting.
So yes, if the halt decider had never stopped simulating H_Hat, the
simulation would still end because the outer H_Hat would stop simulating
the inner H_Hat at which point it would HALT.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2021-03-11 12:42 -0800 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <5f7bbbb6-cecc-4ac2-9148-5e1ca27e0314n@googlegroups.com> |
| In reply to | #29120 |
On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote:
> On 2021-03-11 12:50, olcott wrote:
> > On 3/11/2021 1:44 PM, André G. Isaak wrote:
> >> On 2021-03-11 12:03, olcott wrote:
> >>> On 3/11/2021 12:54 PM, Kaz Kylheku wrote:
> >>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
> >>>>> On 3/11/2021 10:43 AM, André G. Isaak wrote:
> >>>>>> On 2021-03-10 22:12, olcott wrote:
> >>>>>>> On 3/10/2021 10:51 PM, Richard Damon wrote:
> >>>>>>>> On 3/10/21 10:24 PM, olcott wrote:
> >>>>>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote:
> >>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote:
> >>>>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote:
> >>>>>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion
> >>>>>>>>>>>>>> in your
> >>>>>>>>>>>>>> system,
> >>>>>>>>>>>>>> though! You have an aborting simulator which makes it
> >>>>>>>>>>>>>> possible
> >>>>>>>>>>>>>> for a
> >>>>>>>>>>>>>> recurring call to the same function with the same
> >>>>>>>>>>>>>> arguments to
> >>>>>>>>>>>>>> terminate after a couple nestings, such that Halts suddenly
> >>>>>>>>>>>>>> returns
> >>>>>>>>>>>>>> zero.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> You don't understand the code well enough.
> >>>>>>>>>>>>> Returing 0 does not stop the infinite recursion.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Returning ... does not stop infinite recursion?
> >>>>>>>>>>>>
> >>>>>>>>>>>> What happened to "infinitely recursive calls never, ever, ever
> >>>>>>>>>>>> return
> >>>>>>>>>>>> to their callers, you ignorant jackasses?"
> >>>>>>>>>>>>
> >>>>>>>>>>>> ROFL
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> That is exactly what I mean:
> >>>>>>>>>>> -"infinitely recursive calls never, ever, ever return
> >>>>>>>>>>> -to their callers, you ignorant jackasses!"
> >>>>>>>>>>>
> >>>>>>>>>>> When Halts() simply simulates its input and returns 0 when it
> >>>>>>>>>>> is done
> >>>>>>>>>>
> >>>>>>>>>> Right, but Halts /doesn't/ simply simulate its input when main
> >>>>>>>>>> asks it
> >>>>>>>>>> to decide Halts(H_Hat, H_Hat).
> >>>>>>>>>
> >>>>>>>>> To prove my point I change the code so that it really does simply
> >>>>>>>>> simulate its input. When I tell you that it simply simulates
> >>>>>>>>> its input
> >>>>>>>>> this is a stipulating definition.
> >>>>>>
> >>>>>> You can't 'stipulate' what something does.
> >>>>>>
> >>>>>>>>> When a BASIC program contains the statement
> >>>>>>>>> 100 let X = 5
> >>>>>>>>> You are not free to disagree that X has the value of 5.
> >>>>>>>>>
> >>>>>>>>> Likewise when I say that Halts() simply simulates its input you
> >>>>>>>>> can
> >>>>>>>>> know
> >>>>>>>>> that the code has been changed so that it really does simply
> >>>>>>>>> simulate
> >>>>>>>>> its input. That you disagree with basic facts is a really
> >>>>>>>>> jackass move.
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Changing Halts Everywhere, changes the computation being simulated.
> >>>>>>> Not in a control flow significant way and because you already know
> >>>>>>> this you are a jackass for implying that it does.
> >>>>>>
> >>>>>> Here is a critical test for you. If your Simulate() *really* does
> >>>>>> accurately simulate its input, then the following two ought to behave
> >>>>>> differently:
> >>>>>>
> >>>>>> 1. Simulate(Halts(H_Hat, H_Hat));
> >>>>>> 2. Simulate(Simulate(H_Hat, H_Hat));
> >>>>>>
> >>>>>> André
> >>>>>>
> >>>>>
> >>>>> I haven't finished rewriting the global halt decider so I am not sure
> >>>>> what it would do.
> >>>>>
> >>>>> I did have to correct your syntax and create Simulate2() that takes
> >>>>> three params, Simulate() only takes two params.
> >>>>>
> >>>>> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat );
> >>>>> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat );
> >>>>
> >>>> The problem is that you're making a strawman version of the halting
> >>>> problem.
> >>>>
> >>>> There is no inherent self-reference in the real problem.
> >>> So then H_Hat() does not do the opposite of whatever the halt decider
> >>> decides ABOUT ITS OWN BEHAVIOR ???
> >>
> >> You're making it sounds as if H_Hat is somehow waiting for the its
> >> caller to return an answer and then deviously changing its behaviour
> >> after that answer has been delivered (an impossibility).
> >
> > It is shown that H_Hat() <is> defined to do the opposite of whatever
> > value that Halts() returns.
> >
> > void H_Hat(u32 P)
> > {
> > u32 Input_Would_Halt = Halts(P, P);
> > if (Input_Would_Halt)
> > HERE: goto HERE;
> > }
> >
> > I can't tell that your disagreement with this is dishonest or
> > incompetent. It seems like you are trying to dishonestly apply the
> > fallacy of equivocation error so that your weasel wording is mistaken
> > for truth.
> >
> > Any question that is defined to contradict every answer is an incorrect
> > question.
> >
> > Any decision problem inputs that are defined to contradict both true and
> > false decisions are incorrect inputs.
> >
> > When the input program does opposite of whatever the halt decider
> > decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological
> > self-reference error.
> THERE IS NO SELF REFERENCE!
>
The self reference is that H_Hat (the Turing machine) is fed H_Hat (the
symbol representation of that Turing machine).
PO seems to have focused on the copy of H embedded in H_Hat. If you
use x86 code instead of a symbol representation of the program, it is
indeed one and the same. But if you keep to the original question, they
are different. It's also easier to see that we can make modifications to
the H embedded in H_Hat which don't affect its behaviour, without changing
anything important.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-11 15:01 -0600 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <Wv2dnUEUHZimGNf9nZ2dnUU7-InNnZ2d@giganews.com> |
| In reply to | #29121 |
On 3/11/2021 2:42 PM, Malcolm McLean wrote:
> On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote:
>> On 2021-03-11 12:50, olcott wrote:
>>> On 3/11/2021 1:44 PM, André G. Isaak wrote:
>>>> On 2021-03-11 12:03, olcott wrote:
>>>>> On 3/11/2021 12:54 PM, Kaz Kylheku wrote:
>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>> On 3/11/2021 10:43 AM, André G. Isaak wrote:
>>>>>>>> On 2021-03-10 22:12, olcott wrote:
>>>>>>>>> On 3/10/2021 10:51 PM, Richard Damon wrote:
>>>>>>>>>> On 3/10/21 10:24 PM, olcott wrote:
>>>>>>>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote:
>>>>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion
>>>>>>>>>>>>>>>> in your
>>>>>>>>>>>>>>>> system,
>>>>>>>>>>>>>>>> though! You have an aborting simulator which makes it
>>>>>>>>>>>>>>>> possible
>>>>>>>>>>>>>>>> for a
>>>>>>>>>>>>>>>> recurring call to the same function with the same
>>>>>>>>>>>>>>>> arguments to
>>>>>>>>>>>>>>>> terminate after a couple nestings, such that Halts suddenly
>>>>>>>>>>>>>>>> returns
>>>>>>>>>>>>>>>> zero.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You don't understand the code well enough.
>>>>>>>>>>>>>>> Returing 0 does not stop the infinite recursion.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Returning ... does not stop infinite recursion?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What happened to "infinitely recursive calls never, ever, ever
>>>>>>>>>>>>>> return
>>>>>>>>>>>>>> to their callers, you ignorant jackasses?"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ROFL
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is exactly what I mean:
>>>>>>>>>>>>> -"infinitely recursive calls never, ever, ever return
>>>>>>>>>>>>> -to their callers, you ignorant jackasses!"
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Halts() simply simulates its input and returns 0 when it
>>>>>>>>>>>>> is done
>>>>>>>>>>>>
>>>>>>>>>>>> Right, but Halts /doesn't/ simply simulate its input when main
>>>>>>>>>>>> asks it
>>>>>>>>>>>> to decide Halts(H_Hat, H_Hat).
>>>>>>>>>>>
>>>>>>>>>>> To prove my point I change the code so that it really does simply
>>>>>>>>>>> simulate its input. When I tell you that it simply simulates
>>>>>>>>>>> its input
>>>>>>>>>>> this is a stipulating definition.
>>>>>>>>
>>>>>>>> You can't 'stipulate' what something does.
>>>>>>>>
>>>>>>>>>>> When a BASIC program contains the statement
>>>>>>>>>>> 100 let X = 5
>>>>>>>>>>> You are not free to disagree that X has the value of 5.
>>>>>>>>>>>
>>>>>>>>>>> Likewise when I say that Halts() simply simulates its input you
>>>>>>>>>>> can
>>>>>>>>>>> know
>>>>>>>>>>> that the code has been changed so that it really does simply
>>>>>>>>>>> simulate
>>>>>>>>>>> its input. That you disagree with basic facts is a really
>>>>>>>>>>> jackass move.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Changing Halts Everywhere, changes the computation being simulated.
>>>>>>>>> Not in a control flow significant way and because you already know
>>>>>>>>> this you are a jackass for implying that it does.
>>>>>>>>
>>>>>>>> Here is a critical test for you. If your Simulate() *really* does
>>>>>>>> accurately simulate its input, then the following two ought to behave
>>>>>>>> differently:
>>>>>>>>
>>>>>>>> 1. Simulate(Halts(H_Hat, H_Hat));
>>>>>>>> 2. Simulate(Simulate(H_Hat, H_Hat));
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> I haven't finished rewriting the global halt decider so I am not sure
>>>>>>> what it would do.
>>>>>>>
>>>>>>> I did have to correct your syntax and create Simulate2() that takes
>>>>>>> three params, Simulate() only takes two params.
>>>>>>>
>>>>>>> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat );
>>>>>>> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat );
>>>>>>
>>>>>> The problem is that you're making a strawman version of the halting
>>>>>> problem.
>>>>>>
>>>>>> There is no inherent self-reference in the real problem.
>>>>> So then H_Hat() does not do the opposite of whatever the halt decider
>>>>> decides ABOUT ITS OWN BEHAVIOR ???
>>>>
>>>> You're making it sounds as if H_Hat is somehow waiting for the its
>>>> caller to return an answer and then deviously changing its behaviour
>>>> after that answer has been delivered (an impossibility).
>>>
>>> It is shown that H_Hat() <is> defined to do the opposite of whatever
>>> value that Halts() returns.
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Input_Would_Halt = Halts(P, P);
>>> if (Input_Would_Halt)
>>> HERE: goto HERE;
>>> }
>>>
>>> I can't tell that your disagreement with this is dishonest or
>>> incompetent. It seems like you are trying to dishonestly apply the
>>> fallacy of equivocation error so that your weasel wording is mistaken
>>> for truth.
>>>
>>> Any question that is defined to contradict every answer is an incorrect
>>> question.
>>>
>>> Any decision problem inputs that are defined to contradict both true and
>>> false decisions are incorrect inputs.
>>>
>>> When the input program does opposite of whatever the halt decider
>>> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological
>>> self-reference error.
>> THERE IS NO SELF REFERENCE!
>>
> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the
> symbol representation of that Turing machine).
>
> PO seems to have focused on the copy of H embedded in H_Hat. If you
> use x86 code instead of a symbol representation of the program, it is
> indeed one and the same. But if you keep to the original question, they
> are different.
When H_Hat is the a Turing Machine description that is being simulated
by a halt decider that is defined on the basis of a UTM then the Turing
machine description that the halt decider is simulating is an identical
finite string to the string that is input to H_Hat, hence self-reference.
> It's also easier to see that we can make modifications to
> the H embedded in H_Hat which don't affect its behaviour, without changing
> anything important.
>
--
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-03-11 14:12 -0700 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <s2e13f$84m$1@dont-email.me> |
| In reply to | #29121 |
On 2021-03-11 13:42, Malcolm McLean wrote:
> On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote:
>> On 2021-03-11 12:50, olcott wrote:
>>> On 3/11/2021 1:44 PM, André G. Isaak wrote:
>>>> On 2021-03-11 12:03, olcott wrote:
>>>>> On 3/11/2021 12:54 PM, Kaz Kylheku wrote:
>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>> On 3/11/2021 10:43 AM, André G. Isaak wrote:
>>>>>>>> On 2021-03-10 22:12, olcott wrote:
>>>>>>>>> On 3/10/2021 10:51 PM, Richard Damon wrote:
>>>>>>>>>> On 3/10/21 10:24 PM, olcott wrote:
>>>>>>>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote:
>>>>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion
>>>>>>>>>>>>>>>> in your
>>>>>>>>>>>>>>>> system,
>>>>>>>>>>>>>>>> though! You have an aborting simulator which makes it
>>>>>>>>>>>>>>>> possible
>>>>>>>>>>>>>>>> for a
>>>>>>>>>>>>>>>> recurring call to the same function with the same
>>>>>>>>>>>>>>>> arguments to
>>>>>>>>>>>>>>>> terminate after a couple nestings, such that Halts suddenly
>>>>>>>>>>>>>>>> returns
>>>>>>>>>>>>>>>> zero.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You don't understand the code well enough.
>>>>>>>>>>>>>>> Returing 0 does not stop the infinite recursion.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Returning ... does not stop infinite recursion?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What happened to "infinitely recursive calls never, ever, ever
>>>>>>>>>>>>>> return
>>>>>>>>>>>>>> to their callers, you ignorant jackasses?"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ROFL
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is exactly what I mean:
>>>>>>>>>>>>> -"infinitely recursive calls never, ever, ever return
>>>>>>>>>>>>> -to their callers, you ignorant jackasses!"
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Halts() simply simulates its input and returns 0 when it
>>>>>>>>>>>>> is done
>>>>>>>>>>>>
>>>>>>>>>>>> Right, but Halts /doesn't/ simply simulate its input when main
>>>>>>>>>>>> asks it
>>>>>>>>>>>> to decide Halts(H_Hat, H_Hat).
>>>>>>>>>>>
>>>>>>>>>>> To prove my point I change the code so that it really does simply
>>>>>>>>>>> simulate its input. When I tell you that it simply simulates
>>>>>>>>>>> its input
>>>>>>>>>>> this is a stipulating definition.
>>>>>>>>
>>>>>>>> You can't 'stipulate' what something does.
>>>>>>>>
>>>>>>>>>>> When a BASIC program contains the statement
>>>>>>>>>>> 100 let X = 5
>>>>>>>>>>> You are not free to disagree that X has the value of 5.
>>>>>>>>>>>
>>>>>>>>>>> Likewise when I say that Halts() simply simulates its input you
>>>>>>>>>>> can
>>>>>>>>>>> know
>>>>>>>>>>> that the code has been changed so that it really does simply
>>>>>>>>>>> simulate
>>>>>>>>>>> its input. That you disagree with basic facts is a really
>>>>>>>>>>> jackass move.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Changing Halts Everywhere, changes the computation being simulated.
>>>>>>>>> Not in a control flow significant way and because you already know
>>>>>>>>> this you are a jackass for implying that it does.
>>>>>>>>
>>>>>>>> Here is a critical test for you. If your Simulate() *really* does
>>>>>>>> accurately simulate its input, then the following two ought to behave
>>>>>>>> differently:
>>>>>>>>
>>>>>>>> 1. Simulate(Halts(H_Hat, H_Hat));
>>>>>>>> 2. Simulate(Simulate(H_Hat, H_Hat));
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> I haven't finished rewriting the global halt decider so I am not sure
>>>>>>> what it would do.
>>>>>>>
>>>>>>> I did have to correct your syntax and create Simulate2() that takes
>>>>>>> three params, Simulate() only takes two params.
>>>>>>>
>>>>>>> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat );
>>>>>>> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat );
>>>>>>
>>>>>> The problem is that you're making a strawman version of the halting
>>>>>> problem.
>>>>>>
>>>>>> There is no inherent self-reference in the real problem.
>>>>> So then H_Hat() does not do the opposite of whatever the halt decider
>>>>> decides ABOUT ITS OWN BEHAVIOR ???
>>>>
>>>> You're making it sounds as if H_Hat is somehow waiting for the its
>>>> caller to return an answer and then deviously changing its behaviour
>>>> after that answer has been delivered (an impossibility).
>>>
>>> It is shown that H_Hat() <is> defined to do the opposite of whatever
>>> value that Halts() returns.
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Input_Would_Halt = Halts(P, P);
>>> if (Input_Would_Halt)
>>> HERE: goto HERE;
>>> }
>>>
>>> I can't tell that your disagreement with this is dishonest or
>>> incompetent. It seems like you are trying to dishonestly apply the
>>> fallacy of equivocation error so that your weasel wording is mistaken
>>> for truth.
>>>
>>> Any question that is defined to contradict every answer is an incorrect
>>> question.
>>>
>>> Any decision problem inputs that are defined to contradict both true and
>>> false decisions are incorrect inputs.
>>>
>>> When the input program does opposite of whatever the halt decider
>>> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological
>>> self-reference error.
>> THERE IS NO SELF REFERENCE!
>>
> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the
> symbol representation of that Turing machine).
This, though, isn't really 'self-reference'. We're passing H_Hat a
description of a TM which happens to be itself. We're not actually
passing itself to itself.
> PO seems to have focused on the copy of H embedded in H_Hat. If you
> use x86 code instead of a symbol representation of the program, it is
> indeed one and the same. But if you keep to the original question, they
Even there, though, we don't really have self-reference. When we call
H_Hat(H_Hat), we are passing an address to H_Hat; we are not actually
passing the routine itself. And while it is possible in C to have
something like
int foo(int (*somefunc)(int)) {
...
x = foo(foo);
...
}
It isn't possible to have something like:
int foo(int (*somefunc)(int)) {
...
x = foo(myself);
...
}
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-11 15:26 -0600 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <SYadnR1xL96JFtf9nZ2dnUU7-X_NnZ2d@giganews.com> |
| In reply to | #29126 |
On 3/11/2021 3:12 PM, André G. Isaak wrote:
> On 2021-03-11 13:42, Malcolm McLean wrote:
>> On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote:
>>> On 2021-03-11 12:50, olcott wrote:
>>>> On 3/11/2021 1:44 PM, André G. Isaak wrote:
>>>>> On 2021-03-11 12:03, olcott wrote:
>>>>>> On 3/11/2021 12:54 PM, Kaz Kylheku wrote:
>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>>> On 3/11/2021 10:43 AM, André G. Isaak wrote:
>>>>>>>>> On 2021-03-10 22:12, olcott wrote:
>>>>>>>>>> On 3/10/2021 10:51 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/10/21 10:24 PM, olcott wrote:
>>>>>>>>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion
>>>>>>>>>>>>>>>>> in your
>>>>>>>>>>>>>>>>> system,
>>>>>>>>>>>>>>>>> though! You have an aborting simulator which makes it
>>>>>>>>>>>>>>>>> possible
>>>>>>>>>>>>>>>>> for a
>>>>>>>>>>>>>>>>> recurring call to the same function with the same
>>>>>>>>>>>>>>>>> arguments to
>>>>>>>>>>>>>>>>> terminate after a couple nestings, such that Halts
>>>>>>>>>>>>>>>>> suddenly
>>>>>>>>>>>>>>>>> returns
>>>>>>>>>>>>>>>>> zero.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You don't understand the code well enough.
>>>>>>>>>>>>>>>> Returing 0 does not stop the infinite recursion.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Returning ... does not stop infinite recursion?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What happened to "infinitely recursive calls never, ever,
>>>>>>>>>>>>>>> ever
>>>>>>>>>>>>>>> return
>>>>>>>>>>>>>>> to their callers, you ignorant jackasses?"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> ROFL
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is exactly what I mean:
>>>>>>>>>>>>>> -"infinitely recursive calls never, ever, ever return
>>>>>>>>>>>>>> -to their callers, you ignorant jackasses!"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Halts() simply simulates its input and returns 0 when it
>>>>>>>>>>>>>> is done
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but Halts /doesn't/ simply simulate its input when main
>>>>>>>>>>>>> asks it
>>>>>>>>>>>>> to decide Halts(H_Hat, H_Hat).
>>>>>>>>>>>>
>>>>>>>>>>>> To prove my point I change the code so that it really does
>>>>>>>>>>>> simply
>>>>>>>>>>>> simulate its input. When I tell you that it simply simulates
>>>>>>>>>>>> its input
>>>>>>>>>>>> this is a stipulating definition.
>>>>>>>>>
>>>>>>>>> You can't 'stipulate' what something does.
>>>>>>>>>
>>>>>>>>>>>> When a BASIC program contains the statement
>>>>>>>>>>>> 100 let X = 5
>>>>>>>>>>>> You are not free to disagree that X has the value of 5.
>>>>>>>>>>>>
>>>>>>>>>>>> Likewise when I say that Halts() simply simulates its input you
>>>>>>>>>>>> can
>>>>>>>>>>>> know
>>>>>>>>>>>> that the code has been changed so that it really does simply
>>>>>>>>>>>> simulate
>>>>>>>>>>>> its input. That you disagree with basic facts is a really
>>>>>>>>>>>> jackass move.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Changing Halts Everywhere, changes the computation being
>>>>>>>>>>> simulated.
>>>>>>>>>> Not in a control flow significant way and because you already
>>>>>>>>>> know
>>>>>>>>>> this you are a jackass for implying that it does.
>>>>>>>>>
>>>>>>>>> Here is a critical test for you. If your Simulate() *really* does
>>>>>>>>> accurately simulate its input, then the following two ought to
>>>>>>>>> behave
>>>>>>>>> differently:
>>>>>>>>>
>>>>>>>>> 1. Simulate(Halts(H_Hat, H_Hat));
>>>>>>>>> 2. Simulate(Simulate(H_Hat, H_Hat));
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> I haven't finished rewriting the global halt decider so I am not
>>>>>>>> sure
>>>>>>>> what it would do.
>>>>>>>>
>>>>>>>> I did have to correct your syntax and create Simulate2() that takes
>>>>>>>> three params, Simulate() only takes two params.
>>>>>>>>
>>>>>>>> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat );
>>>>>>>> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat );
>>>>>>>
>>>>>>> The problem is that you're making a strawman version of the halting
>>>>>>> problem.
>>>>>>>
>>>>>>> There is no inherent self-reference in the real problem.
>>>>>> So then H_Hat() does not do the opposite of whatever the halt decider
>>>>>> decides ABOUT ITS OWN BEHAVIOR ???
>>>>>
>>>>> You're making it sounds as if H_Hat is somehow waiting for the its
>>>>> caller to return an answer and then deviously changing its behaviour
>>>>> after that answer has been delivered (an impossibility).
>>>>
>>>> It is shown that H_Hat() <is> defined to do the opposite of whatever
>>>> value that Halts() returns.
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Input_Would_Halt = Halts(P, P);
>>>> if (Input_Would_Halt)
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> I can't tell that your disagreement with this is dishonest or
>>>> incompetent. It seems like you are trying to dishonestly apply the
>>>> fallacy of equivocation error so that your weasel wording is mistaken
>>>> for truth.
>>>>
>>>> Any question that is defined to contradict every answer is an incorrect
>>>> question.
>>>>
>>>> Any decision problem inputs that are defined to contradict both true
>>>> and
>>>> false decisions are incorrect inputs.
>>>>
>>>> When the input program does opposite of whatever the halt decider
>>>> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological
>>>> self-reference error.
>>> THERE IS NO SELF REFERENCE!
>>>
>> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the
>> symbol representation of that Turing machine).
>
> This, though, isn't really 'self-reference'. We're passing H_Hat a
> description of a TM which happens to be itself. We're not actually
> passing itself to itself.
>
>> PO seems to have focused on the copy of H embedded in H_Hat. If you
>> use x86 code instead of a symbol representation of the program, it is
>> indeed one and the same. But if you keep to the original question, they
>
> Even there, though, we don't really have self-reference.
In the case where H_Hat is defined to do that opposite of whatever the
halt decider decides and The finite string TM desciption of H_Hat is
being simulated in a halt decider that was adapted from a UTM then we
have the finite string TM description of H_Hat doing the opposite of
whatever the halt decider decides about this exact same finite string TM
description.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-03-11 21:54 +0000 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <20210311135230.557@kylheku.com> |
| In reply to | #29130 |
On 2021-03-11, olcott <NoOne@NoWhere.com> wrote: >> Even there, though, we don't really have self-reference. > In the case where H_Hat is defined to do that opposite of whatever the H_Hat can easily receive P by value rather than by reference, and P can be H_Hat. -- TXR Programming Language: http://nongnu.org/txr Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-03-11 21:52 +0000 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <20210311134633.498@kylheku.com> |
| In reply to | #29126 |
On 2021-03-11, André G Isaak <agisaak@gm.invalid> wrote:
> On 2021-03-11 13:42, Malcolm McLean wrote:
>> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the
>> symbol representation of that Turing machine).
>
> This, though, isn't really 'self-reference'. We're passing H_Hat a
> description of a TM which happens to be itself. We're not actually
> passing itself to itself.
Moreover, an implementation of Halts(P, I) and of H_Hat, can use
pass-by-value rather than pass-by-reference.
Thus is it can be that when H_Hat receives something resembling itself
as argument P, it's not actually a reference to itself, but a copy.
A copy of oneself is not a reference, therefore it is incorrect
to talk about "self-reference".
Since, like, this is software engineering, and all. Don't confuse
me with mathematical logic!
In "This sentence is false" and "What answer would Jack give to this
question?", the pronoun "this" is a reference. It cannot be a copy,
because that would result in a non-terminating expansion of This:
'This sentence is false' is false
^^^^^^^^^^^^^
expand again
'"This sentence is false" is false' is false
^^^^^^^^^^^^^
expand again
'"`This sentence is false` is false" is false' is false
^^^^^^^^^^^^^
The Liar Paradox critically depends on reference.
We have no such problem with H_Hat, which can cheerfully receive
a full copy of itself as an argument.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-11 15:46 -0600 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <rZydnTc9ZuoHEtf9nZ2dnUU7-eudnZ2d@giganews.com> |
| In reply to | #29121 |
On 3/11/2021 2:42 PM, Malcolm McLean wrote:
> On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote:
>> On 2021-03-11 12:50, olcott wrote:
>>> On 3/11/2021 1:44 PM, André G. Isaak wrote:
>>>> On 2021-03-11 12:03, olcott wrote:
>>>>> On 3/11/2021 12:54 PM, Kaz Kylheku wrote:
>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>> On 3/11/2021 10:43 AM, André G. Isaak wrote:
>>>>>>>> On 2021-03-10 22:12, olcott wrote:
>>>>>>>>> On 3/10/2021 10:51 PM, Richard Damon wrote:
>>>>>>>>>> On 3/10/21 10:24 PM, olcott wrote:
>>>>>>>>>>> On 3/10/2021 9:04 PM, Kaz Kylheku wrote:
>>>>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>> On 3/10/2021 8:43 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>> On 2021-03-11, olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>>>> On 3/10/2021 6:18 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>> That's not a valid runaway-recursion-detecting criterion
>>>>>>>>>>>>>>>> in your
>>>>>>>>>>>>>>>> system,
>>>>>>>>>>>>>>>> though! You have an aborting simulator which makes it
>>>>>>>>>>>>>>>> possible
>>>>>>>>>>>>>>>> for a
>>>>>>>>>>>>>>>> recurring call to the same function with the same
>>>>>>>>>>>>>>>> arguments to
>>>>>>>>>>>>>>>> terminate after a couple nestings, such that Halts suddenly
>>>>>>>>>>>>>>>> returns
>>>>>>>>>>>>>>>> zero.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You don't understand the code well enough.
>>>>>>>>>>>>>>> Returing 0 does not stop the infinite recursion.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Returning ... does not stop infinite recursion?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What happened to "infinitely recursive calls never, ever, ever
>>>>>>>>>>>>>> return
>>>>>>>>>>>>>> to their callers, you ignorant jackasses?"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ROFL
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is exactly what I mean:
>>>>>>>>>>>>> -"infinitely recursive calls never, ever, ever return
>>>>>>>>>>>>> -to their callers, you ignorant jackasses!"
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Halts() simply simulates its input and returns 0 when it
>>>>>>>>>>>>> is done
>>>>>>>>>>>>
>>>>>>>>>>>> Right, but Halts /doesn't/ simply simulate its input when main
>>>>>>>>>>>> asks it
>>>>>>>>>>>> to decide Halts(H_Hat, H_Hat).
>>>>>>>>>>>
>>>>>>>>>>> To prove my point I change the code so that it really does simply
>>>>>>>>>>> simulate its input. When I tell you that it simply simulates
>>>>>>>>>>> its input
>>>>>>>>>>> this is a stipulating definition.
>>>>>>>>
>>>>>>>> You can't 'stipulate' what something does.
>>>>>>>>
>>>>>>>>>>> When a BASIC program contains the statement
>>>>>>>>>>> 100 let X = 5
>>>>>>>>>>> You are not free to disagree that X has the value of 5.
>>>>>>>>>>>
>>>>>>>>>>> Likewise when I say that Halts() simply simulates its input you
>>>>>>>>>>> can
>>>>>>>>>>> know
>>>>>>>>>>> that the code has been changed so that it really does simply
>>>>>>>>>>> simulate
>>>>>>>>>>> its input. That you disagree with basic facts is a really
>>>>>>>>>>> jackass move.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Changing Halts Everywhere, changes the computation being simulated.
>>>>>>>>> Not in a control flow significant way and because you already know
>>>>>>>>> this you are a jackass for implying that it does.
>>>>>>>>
>>>>>>>> Here is a critical test for you. If your Simulate() *really* does
>>>>>>>> accurately simulate its input, then the following two ought to behave
>>>>>>>> differently:
>>>>>>>>
>>>>>>>> 1. Simulate(Halts(H_Hat, H_Hat));
>>>>>>>> 2. Simulate(Simulate(H_Hat, H_Hat));
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> I haven't finished rewriting the global halt decider so I am not sure
>>>>>>> what it would do.
>>>>>>>
>>>>>>> I did have to correct your syntax and create Simulate2() that takes
>>>>>>> three params, Simulate() only takes two params.
>>>>>>>
>>>>>>> Simulate2( (u32)Halts, (u32)H_Hat, (u32)H_Hat );
>>>>>>> Simulate2( (u32)Simulate, (u32)H_Hat, (u32)H_Hat );
>>>>>>
>>>>>> The problem is that you're making a strawman version of the halting
>>>>>> problem.
>>>>>>
>>>>>> There is no inherent self-reference in the real problem.
>>>>> So then H_Hat() does not do the opposite of whatever the halt decider
>>>>> decides ABOUT ITS OWN BEHAVIOR ???
>>>>
>>>> You're making it sounds as if H_Hat is somehow waiting for the its
>>>> caller to return an answer and then deviously changing its behaviour
>>>> after that answer has been delivered (an impossibility).
>>>
>>> It is shown that H_Hat() <is> defined to do the opposite of whatever
>>> value that Halts() returns.
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Input_Would_Halt = Halts(P, P);
>>> if (Input_Would_Halt)
>>> HERE: goto HERE;
>>> }
>>>
>>> I can't tell that your disagreement with this is dishonest or
>>> incompetent. It seems like you are trying to dishonestly apply the
>>> fallacy of equivocation error so that your weasel wording is mistaken
>>> for truth.
>>>
>>> Any question that is defined to contradict every answer is an incorrect
>>> question.
>>>
>>> Any decision problem inputs that are defined to contradict both true and
>>> false decisions are incorrect inputs.
>>>
>>> When the input program does opposite of whatever the halt decider
>>> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological
>>> self-reference error.
>> THERE IS NO SELF REFERENCE!
>>
> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the
> symbol representation of that Turing machine).
>
I really, really appreciate your support.
> PO seems to have focused on the copy of H embedded in H_Hat. If you
> use x86 code instead of a symbol representation of the program, it is
> indeed one and the same. But if you keep to the original question, they
> are different. It's also easier to see that we can make modifications to
> the H embedded in H_Hat which don't affect its behaviour, without changing
> anything important.
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-11 23:41 +0000 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (honest dialogue?) |
| Message-ID | <875z1xdzrh.fsf@bsb.me.uk> |
| In reply to | #29121 |
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: > On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote: >> On 2021-03-11 12:50, olcott wrote: <cut> >> > When the input program does opposite of whatever the halt decider >> > decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological >> > self-reference error. >> THERE IS NO SELF REFERENCE! >> > The self reference is that H_Hat (the Turing machine) is fed H_Hat (the > symbol representation of that Turing machine). PO does not need anyone helping him to misunderstand self reference. It's a subtle point which many presentations mess up and it has led him astray for years. First off, Turing machines obviously can't reference anything, so there can't be literal self-reference, but the argument against it is much more than just a literal one. Linz (et al) produce what PO sees as "pathological self reference" when a TM is given a string that encodes "itself", and the way this is written in textbooks uses "references" (mathematical symbols) in order to generalise rather be specific: we talk about [H^] being the encoding of H^ rather than writing 938,223,238,176,775,332,131 (halting is about numbers after all) so when we write the key computation H^([H^]) is looks like a very literal self-reference. But that's a red-herring, not only because there is no "referencing" going on with the TMs, but also because the "self" part is wrong too! Every TM fails to be halt decider in infinitely many cases. The proof picks one (because only one is needed), and shallow thinkers like PO then fixate on it. But any machine that behaves sufficiently like H^ will do, and there is no algorithm that can spot them all. What's more there is not human analogy for this situation. PO's favourite self-referential logic questions all miss this point. Every time I taught this, some student (often more than one) would come up with the same notion that PO did when he saw this conventional argument: just write H so as to spot that it is being tricked. Write it to recognise the "self reference" and declare that case to be invalid/nonsense/illegal, whatever. But we could (if we wanted to forestall this argument) present the confounding case as H^([Fx]) where Fx is any one of an infinity of TMs that /behave/ sufficiently like H^ that we get the same contradiction, whilst /looking/ entirely unlike H^ in every respect. Of course, to make the proof work, we would have to have a provable relationship in behaviour, so a student could certainly claim that at least this case can be spotted too, but there would absolutely be no way to confuse this with "self reference" -- there's no reference and no self anymore. I see he has thanked you for you support. The sort of support he needs it not available via Usenet, but failing that, encouraging his delusion (albeit by being misinterpreted) is not helpful to him or to anyone. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-11 17:56 -0600 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (tedious distinction) |
| Message-ID | <bdOdnXUz3fi0M9f9nZ2dnUU7-Y3NnZ2d@giganews.com> |
| In reply to | #29137 |
On 3/11/2021 5:41 PM, Ben Bacarisse wrote: > Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: > >> On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote: >>> On 2021-03-11 12:50, olcott wrote: > <cut> >>>> When the input program does opposite of whatever the halt decider >>>> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological >>>> self-reference error. >>> THERE IS NO SELF REFERENCE! >>> >> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the >> symbol representation of that Turing machine). > > PO does not need anyone helping him to misunderstand self reference. > It's a subtle point which many presentations mess up and it has led him > astray for years. > > First off, Turing machines obviously can't reference anything, so there > can't be literal self-reference, but the argument against it is much > more than just a literal one. When H_Hat is the finite string Turing Machine description that is being simulated by a halt decider that is defined on the basis of a UTM then the Turing machine description that the halt decider is simulating is an identical finite string to the finite string input to H_Hat, hence self-reference, H_Hat is literally a finite string input to itself. When the halt decider itself is being simulated by a master UTM then we no longer need to make the tedious distinction between a TM and its description because every TM that we are discussing <is> a Turing Machine description that is being simulated. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-12 00:52 +0000 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (tedious distinction) |
| Message-ID | <87ft11chxk.fsf@bsb.me.uk> |
| In reply to | #29138 |
olcott <NoOne@NoWhere.com> writes: > On 3/11/2021 5:41 PM, Ben Bacarisse wrote: >> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >> >>> On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote: >>>> On 2021-03-11 12:50, olcott wrote: >> <cut> >>>>> When the input program does opposite of whatever the halt decider >>>>> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological >>>>> self-reference error. >>>> THERE IS NO SELF REFERENCE! >>>> >>> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the >>> symbol representation of that Turing machine). >> >> PO does not need anyone helping him to misunderstand self reference. >> It's a subtle point which many presentations mess up and it has led him >> astray for years. >> >> First off, Turing machines obviously can't reference anything, so there >> can't be literal self-reference, but the argument against it is much >> more than just a literal one. > > When H_Hat is the finite string Turing Machine description that is > being simulated by a halt decider that is defined on the basis of a > UTM then the Turing machine description that the halt decider is > simulating is an identical finite string to the finite string input to > H_Hat, hence self-reference, H_Hat is literally a finite string input > to itself. You didn't read, or did not understand, what I wrote. So, once more for the hard of understanding... Running H^ with [H^] on the tape is not a reference in any literal sense (thought I won't mind if you use the term metaphorically). But [H^] is only one of infinitely many strings with the same problem, so the input need not be anything like an encoding of H^ to show that H fails. Both parts of the term "self reference" are wrong because they don't identify the real problem which is one of "computationally equivalent data" not "self reference". You've spent years looking in the wrong place. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-11 19:10 -0600 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (tedious distinction) |
| Message-ID | <UrudnW1KYLI8Itf9nZ2dnUU7-Y_NnZ2d@giganews.com> |
| In reply to | #29146 |
On 3/11/2021 6:52 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 3/11/2021 5:41 PM, Ben Bacarisse wrote: >>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >>> >>>> On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote: >>>>> On 2021-03-11 12:50, olcott wrote: >>> <cut> >>>>>> When the input program does opposite of whatever the halt decider >>>>>> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological >>>>>> self-reference error. >>>>> THERE IS NO SELF REFERENCE! >>>>> >>>> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the >>>> symbol representation of that Turing machine). >>> >>> PO does not need anyone helping him to misunderstand self reference. >>> It's a subtle point which many presentations mess up and it has led him >>> astray for years. >>> >>> First off, Turing machines obviously can't reference anything, so there >>> can't be literal self-reference, but the argument against it is much >>> more than just a literal one. >> >> When H_Hat is the finite string Turing Machine description that is >> being simulated by a halt decider that is defined on the basis of a >> UTM then the Turing machine description that the halt decider is >> simulating is an identical finite string to the finite string input to >> H_Hat, hence self-reference, H_Hat is literally a finite string input >> to itself. > > You didn't read, or did not understand, what I wrote. So, once more for > the hard of understanding... Running H^ with [H^] on the tape is not a > reference in any literal sense It is not just running H^ with [H^] somewhere on the tape having nothing to do with H^. It is computationally equivalent to: running H^([H^]). which for simplicity can simply be called H^(H^) because every TMD being discussed is simulated by a master UTM. > (thought I won't mind if you use the term > metaphorically). But [H^] is only one of infinitely many strings with > the same problem, so the input need not be anything like an encoding of > H^ to show that H fails. Every time any input to a decider is defined to do that opposite of whatever the halt decider decides it is an incorrect input. When we define the halting problem criteria differently such incorrect inputs cannot possibly be defined then the pathological self-reference error of the original criteria is corrected. > Both parts of the term "self reference" are > wrong because they don't identify the real problem which is one of > "computationally equivalent data" not "self reference". You've spent > years looking in the wrong place. > It does not matter if I call it Jabberwocky it proves that the halting problem has incorrect criteria that once corrected no longer results in the pathological self-reference error of the original criteria: Would the input program halt if the halt decider never stopped simulating it? -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-13 00:21 +0000 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (tedious distinction) |
| Message-ID | <87sg4zc38x.fsf@bsb.me.uk> |
| In reply to | #29149 |
olcott <NoOne@NoWhere.com> writes: > On 3/11/2021 6:52 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 3/11/2021 5:41 PM, Ben Bacarisse wrote: >>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >>>> >>>>> On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote: >>>>>> On 2021-03-11 12:50, olcott wrote: >>>> <cut> >>>>>>> When the input program does opposite of whatever the halt decider >>>>>>> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological >>>>>>> self-reference error. >>>>>> THERE IS NO SELF REFERENCE! >>>>>> >>>>> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the >>>>> symbol representation of that Turing machine). >>>> >>>> PO does not need anyone helping him to misunderstand self reference. >>>> It's a subtle point which many presentations mess up and it has led him >>>> astray for years. >>>> >>>> First off, Turing machines obviously can't reference anything, so there >>>> can't be literal self-reference, but the argument against it is much >>>> more than just a literal one. >>> >>> When H_Hat is the finite string Turing Machine description that is >>> being simulated by a halt decider that is defined on the basis of a >>> UTM then the Turing machine description that the halt decider is >>> simulating is an identical finite string to the finite string input to >>> H_Hat, hence self-reference, H_Hat is literally a finite string input >>> to itself. >> >> You didn't read, or did not understand, what I wrote. So, once more for >> the hard of understanding... Running H^ with [H^] on the tape is not a >> reference in any literal sense > > It is not just running H^ with [H^] somewhere on the tape having > nothing to do with H^. It is computationally equivalent to: running > H^([H^]). > > which for simplicity can simply be called H^(H^) because every TMD > being discussed is simulated by a master UTM. No, because H^ can't be an input to a TM. In your model you've replaced [H^] with a reference to H^, but there is no reference in the original formulation of the problem. One could argue you have added self reference where there was none before. >> (thought I won't mind if you use the term >> metaphorically). But [H^] is only one of infinitely many strings with >> the same problem, so the input need not be anything like an encoding of >> H^ to show that H fails. > > Every time any input to a decider is defined to do that opposite of > whatever the halt decider decides it is an incorrect input. You don't have the background to understand what want to say about this. I can't be bothered to type half lecture about (after all, you could read a book on the subject by now if you wanted to learn) so all I will say is that you can call any set of inputs anything you like. None of the facts change. None of the theorems change. But you feel better so that's something. > When we define the halting problem criteria differently... ... we get a different problem. All the results about actual halting remain unaltered by your definition. As it happens, the new problem is also undecidable, but you simply don't have the background understanding to see that. >> Both parts of the term "self reference" are >> wrong because they don't identify the real problem which is one of >> "computationally equivalent data" not "self reference". You've spent >> years looking in the wrong place. > > It does not matter if I call it Jabberwocky it proves that the halting > problem has incorrect criteria that once corrected no longer results > in the pathological self-reference error of the original criteria: > > Would the input program halt if the halt decider never stopped > simulating it? Nope. The question of whether a TM computation halts or not remains unaltered by your refusal to consider it. And every instance of every one of these decision problems sill has a correct yes/no answer, no matter what you choose to call some of them. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-12 19:57 -0600 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (tedious distinction) |
| Message-ID | <YaKdnafWjaFlhtH9nZ2dnUU7-QPNnZ2d@giganews.com> |
| In reply to | #29197 |
On 3/12/2021 6:21 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 3/11/2021 6:52 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 3/11/2021 5:41 PM, Ben Bacarisse wrote: >>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >>>>> >>>>>> On Thursday, 11 March 2021 at 20:34:59 UTC, André G. Isaak wrote: >>>>>>> On 2021-03-11 12:50, olcott wrote: >>>>> <cut> >>>>>>>> When the input program does opposite of whatever the halt decider >>>>>>>> decides ABOUT ITS OWN BEHAVIOR this is an example of the pathological >>>>>>>> self-reference error. >>>>>>> THERE IS NO SELF REFERENCE! >>>>>>> >>>>>> The self reference is that H_Hat (the Turing machine) is fed H_Hat (the >>>>>> symbol representation of that Turing machine). >>>>> >>>>> PO does not need anyone helping him to misunderstand self reference. >>>>> It's a subtle point which many presentations mess up and it has led him >>>>> astray for years. >>>>> >>>>> First off, Turing machines obviously can't reference anything, so there >>>>> can't be literal self-reference, but the argument against it is much >>>>> more than just a literal one. >>>> >>>> When H_Hat is the finite string Turing Machine description that is >>>> being simulated by a halt decider that is defined on the basis of a >>>> UTM then the Turing machine description that the halt decider is >>>> simulating is an identical finite string to the finite string input to >>>> H_Hat, hence self-reference, H_Hat is literally a finite string input >>>> to itself. >>> >>> You didn't read, or did not understand, what I wrote. So, once more for >>> the hard of understanding... Running H^ with [H^] on the tape is not a >>> reference in any literal sense >> >> It is not just running H^ with [H^] somewhere on the tape having >> nothing to do with H^. It is computationally equivalent to: running >> H^([H^]). >> >> which for simplicity can simply be called H^(H^) because every TMD >> being discussed is simulated by a master UTM. > > No, because H^ can't be an input to a TM. It is still actually [H^] we just don't have to bother to say it because everything <is> a Turing machine description. Those separate things that we used to call TMs are no longer TMs they are TMDs that are being simulated in a UTM. > In your model you've replaced > [H^] with a reference to H^, but there is no reference in the original > formulation of the problem. One could argue you have added self > reference where there was none before. Not really. Even in Linz H^ is passing [H^] and a copy of [H^] to the halt decider. [H^] is the TMD of the actual H^ which is directly executed by any halt decider adapted from a UTM. >>> (thought I won't mind if you use the term >>> metaphorically). But [H^] is only one of infinitely many strings with >>> the same problem, so the input need not be anything like an encoding of >>> H^ to show that H fails. >> >> Every time any input to a decider is defined to do that opposite of >> whatever the halt decider decides it is an incorrect input. > > You don't have the background to understand what want to say about > this. I can't be bothered to type half lecture about (after all, you > could read a book on the subject by now if you wanted to learn) so all > I will say is that you can call any set of inputs anything you like. > None of the facts change. None of the theorems change. But you feel > better so that's something. So basically you are making an assertion utterly bereft of any supporting reasoning what-so-ever as your basis that I am incorrect. That continue to be quite a jackass move. We are using terminology slightly differently and some of the ideas that I must express to make my point do not have any corresponding terms of the art to reference them. None-the-less my basis depends on these ideas. If your feedback was much more specific I could correct this communication error. To some significant extent I am using brand new ideas that no one has ever expressed before and you are rejecting them on the basis that you never heard of them before. >> When we define the halting problem criteria differently... > > ... we get a different problem. All the results about actual halting > remain unaltered by your definition. As it happens, the new problem is > also undecidable, but you simply don't have the background understanding > to see that. So if it is an actual verifiable fact that the problem itself is definitely incorrect then you will utterly refuse to hear this because it does not correspond to what you learned-by-rote. (1) Most everyone agrees that the halting problem is not incorrect. (2) It is an axiom that every broad human consensus is always utterly infallible. (3) Therefore I must be wrong. -- 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-03-13 16:59 -0500 |
| Subject | Re: Refuting the halting problem proofs with fully operational code (tedious distinction) |
| Message-ID | <SAa3I.49433$rG7.23672@fx42.iad> |
| In reply to | #29200 |
On 3/12/21 8:57 PM, olcott wrote: > Those separate things that we used to call TMs are no longer TMs they > are TMDs that are being simulated in a UTM. > Except by your current description we have no UTM as it has a global halt decider built in, so it is NOT a UTM equivalent. Also, when 'nesting' calls, we can't run 'any' TM, as the code space for the machines is not isolated.
[toc] | [prev] | [next] | [standalone]
Page 17 of 23 — ← Prev page 1 … 15 16 [17] 18 19 … 23 Next page →
Back to top | Article view | comp.theory
csiph-web