Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #29419 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-03-16 11:30 -0500 |
| Last post | 2021-03-18 12:58 -0500 |
| Articles | 20 on this page of 713 — 15 participants |
Back to article view | Back to comp.theory
A UTM halt decider <is> a pure function of its inputs olcott <NoOne@NoWhere.com> - 2021-03-16 11:30 -0500
Re: A UTM halt decider <is> a pure function of its inputs olcott <NoOne@NoWhere.com> - 2021-03-18 07:38 -0500
Re: A UTM halt decider <is> a pure function of its inputs Richard Damon <Richard@Damon-Family.org> - 2021-03-18 23:20 -0400
Re: A UTM halt decider <is> a pure function of its inputs olcott <NoOne@NoWhere.com> - 2021-03-18 22:26 -0500
Re: A UTM halt decider <is> a pure function of its inputs Richard Damon <Richard@Damon-Family.org> - 2021-03-19 10:52 -0400
Re: A UTM halt decider <is> a pure function of its inputs (kittens) olcott <NoOne@NoWhere.com> - 2021-03-19 09:57 -0500
Re: A UTM halt decider <is> a pure function of its inputs (kittens) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 11:27 -0400
Re: A UTM halt decider <is> a pure function of its inputs (kittens) olcott <NoOne@NoWhere.com> - 2021-03-19 10:42 -0500
Re: A UTM halt decider <is> a pure function of its inputs (kittens) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 11:50 -0400
Re: A UTM halt decider <is> a pure function of its inputs (kittens are purring) olcott <NoOne@NoWhere.com> - 2021-03-19 10:54 -0500
Re: A UTM halt decider <is> a pure function of its inputs (kittens are purring) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 12:16 -0400
Re: A UTM halt decider <is> a pure function of its inputs (kittens are purring) olcott <NoOne@NoWhere.com> - 2021-03-19 11:37 -0500
Re: A UTM halt decider <is> a pure function of its inputs (kittens are purring) André G. Isaak <agisaak@gm.invalid> - 2021-03-19 11:32 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-19 12:50 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-19 12:35 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-19 13:52 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-19 14:11 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-19 13:51 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-19 15:14 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-19 14:24 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-19 15:31 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-19 14:43 -0600
Re: A UTM halt decider <is> a pure function of its inputs (clueless) olcott <NoOne@NoWhere.com> - 2021-03-19 15:46 -0500
Re: A UTM halt decider <is> a pure function of its inputs (clueless) André G. Isaak <agisaak@gm.invalid> - 2021-03-19 15:29 -0600
Re: A UTM halt decider <is> a pure function of its inputs (clueless) olcott <NoOne@NoWhere.com> - 2021-03-19 16:43 -0500
Re: A UTM halt decider <is> a pure function of its inputs (clueless) André G. Isaak <agisaak@gm.invalid> - 2021-03-19 18:02 -0600
Re: A UTM halt decider <is> a pure function of its inputs (clueless) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 18:28 -0400
Re: A UTM halt decider <is> a pure function of its inputs (clueless is proven) olcott <NoOne@NoWhere.com> - 2021-03-19 17:57 -0500
Re: A UTM halt decider <is> a pure function of its inputs (clueless is proven) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 20:49 -0400
Re: A UTM halt decider <is> a pure function of its inputs (clueless is proven) olcott <NoOne@NoWhere.com> - 2021-03-19 19:58 -0500
Re: A UTM halt decider <is> a pure function of its inputs (clueless is proven) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-20 01:11 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Kaz is not clueless) olcott <NoOne@NoWhere.com> - 2021-03-19 20:26 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Kaz is not clueless) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 21:50 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Kaz is not clueless) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-20 01:59 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) olcott <NoOne@NoWhere.com> - 2021-03-19 21:18 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-20 02:27 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) olcott <NoOne@NoWhere.com> - 2021-03-19 21:36 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 23:12 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) olcott <NoOne@NoWhere.com> - 2021-03-19 22:19 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) Richard Damon <Richard@Damon-Family.org> - 2021-03-20 06:21 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-19 20:24 -0700
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) olcott <NoOne@NoWhere.com> - 2021-03-19 22:34 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-19 20:43 -0700
Re: A UTM halt decider <is> a pure function of its inputs (halt decider code) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-19 20:44 -0700
Re: A UTM halt decider <is> a pure function of its inputs (clueless is proven) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 21:45 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 16:16 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-21 20:45 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-21 21:06 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-22 12:50 -0700
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-22 14:59 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-22 23:03 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-22 16:40 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-22 23:49 +0000
Re: A UTM halt decider <is> a pure function of its inputs (last objection addressed) olcott <NoOne@NoWhere.com> - 2021-03-22 19:30 -0500
Re: A UTM halt decider <is> a pure function of its inputs (last objection addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-23 02:41 +0000
Re: A UTM halt decider <is> a pure function of its inputs (last objection addressed) olcott <NoOne@NoWhere.com> - 2021-03-22 21:54 -0500
Re: A UTM halt decider <is> a pure function of its inputs (last objection addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-23 03:30 +0000
Re: A UTM halt decider <is> a pure function of its inputs (last objection addressed) olcott <NoOne@NoWhere.com> - 2021-03-23 09:33 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-23 22:36 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) André G. Isaak <agisaak@gm.invalid> - 2021-03-23 22:02 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-23 23:09 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) André G. Isaak <agisaak@gm.invalid> - 2021-03-23 22:15 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-23 23:26 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 08:50 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-24 08:05 -0700
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 10:13 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) André G. Isaak <agisaak@gm.invalid> - 2021-03-24 10:05 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 11:08 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-24 09:48 -0700
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 12:05 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-24 10:28 -0700
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 12:34 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) André G. Isaak <agisaak@gm.invalid> - 2021-03-24 10:52 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 12:19 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 17:20 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) André G. Isaak <agisaak@gm.invalid> - 2021-03-24 17:22 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 19:08 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 19:17 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) André G. Isaak <agisaak@gm.invalid> - 2021-03-24 18:39 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 19:46 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) André G. Isaak <agisaak@gm.invalid> - 2021-03-24 18:59 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) olcott <NoOne@NoWhere.com> - 2021-03-24 20:10 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Turing Equivalence) olcott <NoOne@NoWhere.com> - 2021-03-24 20:18 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) Bonita Montero <Bonita.Montero@gmail.com> - 2021-03-26 14:01 +0100
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding) Bonita Montero <Bonita.Montero@gmail.com> - 2021-03-31 08:19 +0200
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-24 08:21 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-24 08:42 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-24 22:17 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-24 21:54 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 08:26 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 09:28 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-25 15:47 +0000
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 10:56 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-25 10:23 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 11:51 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-25 11:09 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 12:31 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-25 12:15 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 14:35 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-25 14:49 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 16:49 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-25 16:54 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 18:00 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-25 18:25 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 19:44 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 22:18 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 21:27 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 22:56 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-25 22:09 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 23:41 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-25 22:54 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 07:28 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-26 10:07 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 20:27 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-26 19:37 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 20:47 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-26 18:59 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-26 20:21 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-26 19:35 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-26 20:49 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 22:03 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-26 21:23 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-26 22:32 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 07:01 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 09:13 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 10:46 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 08:56 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 10:13 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 11:32 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 09:42 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 10:45 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 12:09 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 11:22 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 14:33 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 10:12 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 11:20 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 10:42 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 12:04 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 11:25 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 12:35 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-27 11:02 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 13:12 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 14:36 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 12:58 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 14:01 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 15:20 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 14:29 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 15:54 -0400
Re: A UTM halt decider <is> a pure function of its inputs (slight change to TM definition) olcott <NoOne@NoWhere.com> - 2021-03-27 15:16 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 14:34 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 15:47 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 16:54 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 16:00 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 18:35 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 17:45 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 19:59 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 19:09 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 20:20 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 19:33 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 18:54 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 19:59 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 19:26 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 21:41 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 21:10 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 22:46 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 22:16 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 23:31 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-28 09:33 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 13:15 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-28 13:16 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-28 00:12 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Jeff Barnett <jbb@notatt.com> - 2021-03-28 01:13 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-28 01:43 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Jeff Barnett <jbb@notatt.com> - 2021-03-28 11:26 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-28 00:24 +0000
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 19:41 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 21:49 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-28 02:42 +0000
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-27 19:48 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 21:52 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 23:15 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 22:31 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-28 04:38 +0000
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 07:27 -0400
Re: A UTM halt decider <is> a pure function of its inputs (pure function) olcott <NoOne@NoWhere.com> - 2021-03-28 08:50 -0500
Re: A UTM halt decider <is> a pure function of its inputs (pure function) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-28 16:58 +0000
Re: A UTM halt decider <is> a pure function of its inputs (pure function) olcott <NoOne@NoWhere.com> - 2021-03-28 12:47 -0500
Re: A UTM halt decider <is> a pure function of its inputs (pure function) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 14:17 -0400
Re: A UTM halt decider <is> a pure function of its inputs (pure function) olcott <NoOne@NoWhere.com> - 2021-03-28 13:35 -0500
Re: A UTM halt decider <is> a pure function of its inputs (pure function) André G. Isaak <agisaak@gm.invalid> - 2021-03-28 13:41 -0600
Re: A UTM halt decider <is> a pure function of its inputs (pure function) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-28 13:42 -0700
Re: A UTM halt decider <is> a pure function of its inputs (pure function) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 17:11 -0400
Re: A UTM halt decider <is> a pure function of its inputs (pure function) olcott <NoOne@NoWhere.com> - 2021-03-28 16:17 -0500
Re: A UTM halt decider <is> a pure function of its inputs (pure function) Jeff Barnett <jbb@notatt.com> - 2021-03-28 17:20 -0600
Re: A UTM halt decider <is> a pure function of its inputs (computability) olcott <NoOne@NoWhere.com> - 2021-03-28 18:28 -0500
Re: A UTM halt decider <is> a pure function of its inputs (computability) Jeff Barnett <jbb@notatt.com> - 2021-03-28 18:23 -0600
Re: A UTM halt decider <is> a pure function of its inputs (computability) olcott <NoOne@NoWhere.com> - 2021-03-28 19:33 -0500
Re: A UTM halt decider <is> a pure function of its inputs (computability) Jeff Barnett <jbb@notatt.com> - 2021-03-28 20:51 -0600
Re: A UTM halt decider <is> a pure function of its inputs (computability) olcott <NoOne@NoWhere.com> - 2021-03-28 22:02 -0500
Re: A UTM halt decider <is> a pure function of its inputs (computability) Jeff Barnett <jbb@notatt.com> - 2021-03-28 21:18 -0600
Re: A UTM halt decider <is> a pure function of its inputs (pure function) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 16:43 -0400
Re: A UTM halt decider <is> a pure function of its inputs (pure function) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 13:20 -0400
Re: A UTM halt decider <is> a pure function of its inputs (pure function) olcott <NoOne@NoWhere.com> - 2021-03-28 13:13 -0500
Re: A UTM halt decider <is> a pure function of its inputs (pure function) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 16:55 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-28 04:33 +0000
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 14:57 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 16:33 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 13:25 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 14:33 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 15:59 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-27 13:08 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 15:11 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 16:50 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 16:02 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 18:12 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 14:25 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 15:44 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 14:51 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 15:54 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 15:03 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-27 14:09 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 16:19 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 15:34 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 18:22 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 16:26 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 16:15 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 18:40 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 19:06 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 20:22 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-27 14:01 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 16:16 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 15:31 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-27 14:37 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 16:51 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 16:19 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-27 15:30 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 16:42 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-27 16:04 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 18:17 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 20:04 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 19:13 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 20:30 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 18:59 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 20:02 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 19:27 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 21:55 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 21:48 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 23:23 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 23:15 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 07:29 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-28 10:31 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-28 10:33 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 13:23 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-28 13:23 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 14:08 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) André G. Isaak <agisaak@gm.invalid> - 2021-03-28 13:26 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 14:50 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Alan Mackenzie <acm@muc.de> - 2021-03-28 20:05 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 15:32 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 17:05 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 16:10 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 17:37 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 16:44 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 20:50 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 19:57 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 21:20 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 20:30 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 22:55 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 22:07 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 23:33 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 23:15 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-29 22:29 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 21:34 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 07:58 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-30 05:46 -0700
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <polcott2@gmail.com> - 2021-03-30 08:58 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 15:32 +0000
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 12:37 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 14:15 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 13:34 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 19:13 +0000
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 14:22 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 19:29 +0000
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 15:11 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 15:58 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 15:05 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 16:31 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 16:05 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 17:14 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-31 09:32 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 11:33 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-31 11:01 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 13:17 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-30 21:37 +0100
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 15:52 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 19:09 +0000
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 14:20 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 19:28 +0000
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 15:09 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 21:15 +0000
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) olcott <NoOne@NoWhere.com> - 2021-03-31 09:19 -0500
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 10:46 -0400
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) olcott <NoOne@NoWhere.com> - 2021-03-31 10:06 -0500
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 11:46 -0400
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-31 15:23 +0000
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) olcott <NoOne@NoWhere.com> - 2021-03-31 10:50 -0500
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 12:05 -0400
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) olcott <NoOne@NoWhere.com> - 2021-03-31 11:11 -0500
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 12:41 -0400
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-31 17:40 +0000
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) olcott <NoOne@NoWhere.com> - 2021-03-31 12:55 -0500
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-01 00:52 +0000
Re: A UTM halt decider <is> a pure function of its inputs(complete halt deciding system) R Kym Horsell <kym@kymhorsell.com> - 2021-04-01 01:30 +0000
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 16:00 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 15:07 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 16:34 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 15:57 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 17:16 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-31 09:26 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 10:53 -0400
Re: A UTM halt decider <is> a pure function of its inputs (jackass) olcott <NoOne@NoWhere.com> - 2021-03-31 10:09 -0500
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 11:59 -0400
Re: A UTM halt decider <is> a pure function of its inputs (jackass) olcott <NoOne@NoWhere.com> - 2021-03-31 11:04 -0500
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 12:46 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 12:21 -0400
Re: A UTM halt decider <is> a pure function of its inputs (stupid mistake) olcott <NoOne@NoWhere.com> - 2021-03-30 09:30 -0500
Re: A UTM halt decider <is> a pure function of its inputs (stupid mistake) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 12:21 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-29 11:32 +0100
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Andy Walker <anw@cuboid.co.uk> - 2021-03-28 23:16 +0100
Re: A UTM halt decider <is> a pure function of its inputs (computability) olcott <NoOne@NoWhere.com> - 2021-03-28 17:38 -0500
Re: A UTM halt decider <is> a pure function of its inputs (computability) Andy Walker <anw@cuboid.co.uk> - 2021-03-29 00:34 +0100
Re: A UTM halt decider <is> a pure function of its inputs (computability) olcott <NoOne@NoWhere.com> - 2021-03-28 19:02 -0500
Re: A UTM halt decider <is> a pure function of its inputs (computability) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 21:13 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-28 20:26 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 23:10 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-28 22:27 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 23:45 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-28 23:30 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) Richard Damon <Richard@Damon-Family.org> - 2021-03-29 22:30 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 21:36 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 10:45 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 11:53 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 11:43 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 15:00 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 14:10 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 15:57 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 15:36 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 17:42 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-29 22:56 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 18:51 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 00:21 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 19:45 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 18:41 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 20:22 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 19:25 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 20:48 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 20:06 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-29 21:12 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) Richard Damon <Richard@Damon-Family.org> - 2021-03-29 22:34 -0400
Re: A UTM halt decider <is> a pure function of its inputs (the power of C) olcott <NoOne@NoWhere.com> - 2021-03-29 21:41 -0500
Re: A UTM halt decider <is> a pure function of its inputs (the power of C) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 08:04 -0400
Re: A UTM halt decider <is> a pure function of its inputs (the power of C) olcott <NoOne@NoWhere.com> - 2021-03-30 09:39 -0500
Re: A UTM halt decider <is> a pure function of its inputs (the power of C) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 15:21 +0000
Re: A UTM halt decider <is> a pure function of its inputs (the power of C) olcott <NoOne@NoWhere.com> - 2021-03-30 10:42 -0500
Re: A UTM halt decider <is> a pure function of its inputs (the power of C) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 15:59 +0000
Re: A UTM halt decider <is> a pure function of its inputs (the power of C) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 12:20 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 21:25 -0600
Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) olcott <NoOne@NoWhere.com> - 2021-03-29 22:38 -0500
Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 22:11 -0600
Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) olcott <NoOne@NoWhere.com> - 2021-03-29 23:24 -0500
Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 22:57 -0600
Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 08:09 -0400
Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) olcott <NoOne@NoWhere.com> - 2021-03-30 09:43 -0500
Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 15:29 +0000
Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 12:46 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-30 14:53 +0100
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) olcott <NoOne@NoWhere.com> - 2021-03-30 09:04 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Computability!) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 12:25 -0400
Re: A UTM halt decider <is> a pure function of its inputs (computability) Andy Walker <anw@cuboid.co.uk> - 2021-03-29 18:59 +0100
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-29 15:28 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Andy Walker <anw@cuboid.co.uk> - 2021-03-31 00:02 +0100
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 18:16 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-31 00:34 +0000
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 19:40 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-31 04:35 +0000
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 23:44 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 06:44 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-31 08:31 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 11:10 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-31 10:19 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-31 15:25 +0000
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-31 10:51 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 12:02 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-31 11:05 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 12:49 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 21:45 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 20:52 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 22:12 -0400
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) olcott <NoOne@NoWhere.com> - 2021-03-30 21:15 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 23:33 -0400
Re: A UTM halt decider <is> a pure function of its inputs (jackass) olcott <NoOne@NoWhere.com> - 2021-03-30 22:49 -0500
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-31 06:04 +0000
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-31 03:27 -0700
Re: A UTM halt decider <is> a pure function of its inputs (jackass) olcott <NoOne@NoWhere.com> - 2021-03-31 08:32 -0500
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 06:34 -0400
Re: A UTM halt decider <is> a pure function of its inputs (jackass) olcott <NoOne@NoWhere.com> - 2021-03-31 08:28 -0500
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 11:24 -0400
Re: A UTM halt decider <is> a pure function of its inputs (jackass) olcott <NoOne@NoWhere.com> - 2021-03-31 10:58 -0500
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 13:01 -0400
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-31 17:36 +0000
Re: A UTM halt decider <is> a pure function of its inputs (jackass) olcott <NoOne@NoWhere.com> - 2021-03-31 13:13 -0500
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 14:36 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-03-31 13:56 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 16:07 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-03-31 15:21 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 16:56 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-03-31 16:14 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 17:28 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-03-31 16:34 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 17:56 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-03-31 17:04 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 20:29 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-03-31 19:46 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 22:09 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-03-31 21:32 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-03-31 22:52 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-03-31 22:06 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 07:29 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 11:15 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 12:43 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 11:57 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-01 17:23 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 12:43 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-02 15:02 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-02 10:15 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 11:37 -0400
Re: A UTM halt decider <is> a pure function of its inputs (ignoramus) olcott <NoOne@NoWhere.com> - 2021-04-02 11:25 -0500
Re: A UTM halt decider <is> a pure function of its inputs (ignoramus) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 15:11 -0400
Re: A UTM halt decider <is> a pure function of its inputs (ignoramus^2) olcott <NoOne@NoWhere.com> - 2021-04-02 14:24 -0500
Re: A UTM halt decider <is> a pure function of its inputs (ignoramus^2) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 16:01 -0400
Re: A UTM halt decider <is> a pure function of its inputs (ignoramus^3) olcott <NoOne@NoWhere.com> - 2021-04-02 15:15 -0500
Re: A UTM halt decider <is> a pure function of its inputs (ignoramus^3) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 18:13 -0400
Re: A UTM halt decider <is> a pure function of its inputs (ignoramus^3) olcott <NoOne@NoWhere.com> - 2021-04-02 17:19 -0500
Re: A UTM halt decider <is> a pure function of its inputs (ignoramus^3) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 18:27 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-02 16:37 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-02 12:03 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-02 13:48 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 15:25 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-02 14:47 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 17:30 -0400
Re: A UTM halt decider <is> a pure function of its inputs (ignoramus^3) olcott <NoOne@NoWhere.com> - 2021-04-02 16:32 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-02 19:27 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-02 14:52 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-03 02:50 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-05 02:39 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-05 19:24 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-05 20:55 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-05 16:21 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-05 15:00 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-05 15:17 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-05 19:27 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-05 15:02 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-05 12:39 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) André G. Isaak <agisaak@gm.invalid> - 2021-04-05 11:59 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) André G. Isaak <agisaak@gm.invalid> - 2021-04-05 12:15 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-05 13:21 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-05 18:49 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-05 13:58 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-05 20:09 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-05 19:17 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-05 20:29 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-04-06 01:35 -0700
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-06 12:35 +0100
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 09:24 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 10:28 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 09:36 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 11:13 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 10:27 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 11:42 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 10:51 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-06 17:42 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) André G. Isaak <agisaak@gm.invalid> - 2021-04-06 13:32 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 16:02 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 15:36 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 16:46 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-07 00:34 +0100
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 18:48 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) André G. Isaak <agisaak@gm.invalid> - 2021-04-06 18:06 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 19:20 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) André G. Isaak <agisaak@gm.invalid> - 2021-04-06 18:38 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 20:06 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) André G. Isaak <agisaak@gm.invalid> - 2021-04-06 19:46 -0600
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 22:17 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-07 13:16 +0100
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Alan Mackenzie <acm@muc.de> - 2021-04-07 12:40 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-07 13:25 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-07 10:26 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-07 16:04 +0100
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-07 11:22 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-07 22:05 +0100
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 09:25 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 10:30 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 09:41 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-06 15:17 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 10:34 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 11:48 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 11:00 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 12:15 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 11:29 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 12:48 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 12:09 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 13:23 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 12:54 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 14:20 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 15:05 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 16:54 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 17:51 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 11:18 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 10:37 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-06 17:34 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 12:52 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-06 18:02 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 13:12 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-06 14:32 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Peter <peterxpercival@hotmail.com> - 2021-04-06 20:50 +0100
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-07 18:52 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-04-06 17:26 -0700
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-06 19:57 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-05 18:48 +0000
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) olcott <NoOne@NoWhere.com> - 2021-04-05 13:57 -0500
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-05 20:32 -0400
Re: A UTM halt decider <is> a pure function of its inputs (halt deciding principle) Richard Damon <Richard@Damon-Family.org> - 2021-04-05 20:11 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 13:47 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 14:16 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 16:00 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 15:07 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 17:06 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 16:44 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 15:56 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 17:16 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 16:39 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 18:00 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 17:05 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 18:35 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) André G. Isaak <agisaak@gm.invalid> - 2021-04-01 16:38 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 17:10 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 18:38 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 18:06 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 19:17 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 18:55 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) André G. Isaak <agisaak@gm.invalid> - 2021-04-01 18:29 -0600
Re: A UTM halt decider <is> a pure function of its inputs (TM relative addressing) olcott <NoOne@NoWhere.com> - 2021-04-01 20:03 -0500
Re: A UTM halt decider <is> a pure function of its inputs (TM relative addressing) André G. Isaak <agisaak@gm.invalid> - 2021-04-01 19:23 -0600
Re: A UTM halt decider <is> a pure function of its inputs (TM relative addressing) olcott <NoOne@NoWhere.com> - 2021-04-01 20:34 -0500
Re: A UTM halt decider <is> a pure function of its inputs (TM relative addressing) André G. Isaak <agisaak@gm.invalid> - 2021-04-01 19:54 -0600
Re: A UTM halt decider <is> a pure function of its inputs (TM relative addressing) olcott <NoOne@NoWhere.com> - 2021-04-01 21:09 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-01 22:46 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 21:58 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 07:54 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <polcott2@gmail.com> - 2021-04-02 09:29 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 11:04 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-02 10:21 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 11:47 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-02 11:37 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 15:27 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-02 15:00 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) André G. Isaak <agisaak@gm.invalid> - 2021-04-02 14:22 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) olcott <NoOne@NoWhere.com> - 2021-04-02 15:32 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 17:43 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) olcott <NoOne@NoWhere.com> - 2021-04-02 17:13 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 18:47 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) André G. Isaak <agisaak@gm.invalid> - 2021-04-02 16:47 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) olcott <NoOne@NoWhere.com> - 2021-04-02 18:12 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 19:28 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) André G. Isaak <agisaak@gm.invalid> - 2021-04-02 20:39 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) Andy Walker <anw@cuboid.co.uk> - 2021-04-03 11:31 +0100
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-04-03 08:49 -0700
Re: A UTM halt decider <is> a pure function of its inputs (Original H and H^) Andy Walker <anw@cuboid.co.uk> - 2021-04-03 21:00 +0100
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 17:38 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-02 17:09 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Richard Damon <Richard@Damon-Family.org> - 2021-04-02 19:08 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) Bonita Montero <Bonita.Montero@gmail.com> - 2021-04-02 01:46 +0200
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-04-01 18:56 -0500
Re: A UTM halt decider <is> a pure function of its inputs (jackass) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-01 00:58 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Pure function of COFF file) olcott <NoOne@NoWhere.com> - 2021-03-31 20:23 -0500
Re: A UTM halt decider <is> a pure function of its inputs (epiphany) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-31 04:40 +0000
Re: A UTM halt decider <is> a pure function of its inputs (computability) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-29 11:11 +0100
Re: A UTM halt decider <is> a pure function of its inputs (computability) Andy Walker <anw@cuboid.co.uk> - 2021-03-29 19:02 +0100
Re: A UTM halt decider <is> a pure function of its inputs (computability) olcott <NoOne@NoWhere.com> - 2021-03-29 15:52 -0500
Re: A UTM halt decider <is> a pure function of its inputs (computability) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 20:59 -0400
Re: A UTM halt decider <is> a pure function of its inputs (computability) olcott <NoOne@NoWhere.com> - 2021-03-28 20:02 -0500
Re: A UTM halt decider <is> a pure function of its inputs (computability) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 21:15 -0400
Re: A UTM halt decider <is> a pure function of its inputs (computability) olcott <NoOne@NoWhere.com> - 2021-03-28 20:38 -0500
Re: A UTM halt decider <is> a pure function of its inputs (computability) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 23:20 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-28 14:11 -0700
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 16:30 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Alan Mackenzie <acm@muc.de> - 2021-03-28 21:12 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-28 14:17 -0700
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 16:32 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 17:42 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 21:59 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 23:24 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 23:09 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) André G. Isaak <agisaak@gm.invalid> - 2021-03-29 10:48 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-29 22:30 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 21:36 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 03:39 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 22:51 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 05:28 +0000
Re: A UTM halt decider <is> a pure function of its inputs (HP undecidability) olcott <NoOne@NoWhere.com> - 2021-03-30 09:20 -0500
Re: A UTM halt decider <is> a pure function of its inputs (HP undecidability) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 15:03 +0000
Re: A UTM halt decider <is> a pure function of its inputs (HP undecidability) olcott <NoOne@NoWhere.com> - 2021-03-30 10:08 -0500
Re: A UTM halt decider <is> a pure function of its inputs (HP undecidability) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 15:33 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 08:13 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-30 09:47 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-30 16:32 +0100
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-30 10:46 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-30 15:56 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 12:37 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-30 12:36 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-29 06:53 -0700
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 08:57 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-29 14:30 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 09:47 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-29 20:15 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 15:46 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-29 22:53 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 18:30 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-29 22:14 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-28 18:12 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Alan Mackenzie <acm@muc.de> - 2021-03-29 12:59 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 08:56 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Alan Mackenzie <acm@muc.de> - 2021-03-29 14:33 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 09:49 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Alan Mackenzie <acm@muc.de> - 2021-03-29 15:11 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 11:02 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Alan Mackenzie <acm@muc.de> - 2021-03-29 16:50 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 12:10 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Alan Mackenzie <acm@muc.de> - 2021-03-29 17:40 +0000
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-29 21:25 +0100
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) olcott <NoOne@NoWhere.com> - 2021-03-29 15:52 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-30 02:43 +0100
Re: A UTM halt decider <is> a pure function of its inputs (liar paradox like structure is moot) olcott <NoOne@NoWhere.com> - 2021-03-29 20:54 -0500
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Andy Walker <anw@cuboid.co.uk> - 2021-03-28 23:05 +0100
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 17:21 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 17:28 -0400
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) André G. Isaak <agisaak@gm.invalid> - 2021-03-28 19:18 -0600
Re: A UTM halt decider <is> a pure function of its inputs (Misinterpretation?) Richard Damon <Richard@Damon-Family.org> - 2021-03-28 21:24 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-28 03:41 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 17:25 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 18:43 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-27 16:21 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 18:27 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 18:26 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 12:10 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote)(TM function call) olcott <NoOne@NoWhere.com> - 2021-03-27 13:22 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote)(TM function call) André G. Isaak <agisaak@gm.invalid> - 2021-03-27 12:48 -0600
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 13:56 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 13:02 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 09:12 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-27 02:00 +0000
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-26 21:06 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 22:52 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 09:27 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 10:51 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 22:01 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-27 09:21 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-27 11:01 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-03-26 05:32 -0700
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-26 09:42 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-26 11:03 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-26 17:02 +0000
Re: A UTM halt decider <is> a pure function of its inputs (undefinable) olcott <NoOne@NoWhere.com> - 2021-03-26 13:00 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undefinable) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 19:44 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undefinable) olcott <NoOne@NoWhere.com> - 2021-03-26 19:19 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undefinable) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 20:33 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-25 23:17 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 07:29 -0400
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) olcott <NoOne@NoWhere.com> - 2021-03-26 10:10 -0500
Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 19:47 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 20:15 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) André G. Isaak <agisaak@gm.invalid> - 2021-03-25 20:33 -0600
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 21:40 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 22:06 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 21:17 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 23:04 -0400
Re: A UTM halt decider <is> a pure function of its inputs (crux basis of rebuttal) olcott <NoOne@NoWhere.com> - 2021-03-25 17:44 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 21:56 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-25 16:47 +0000
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 11:54 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-25 17:02 +0000
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 12:07 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-25 18:13 +0000
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 12:03 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 12:18 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 22:37 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 21:48 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 23:21 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 22:24 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 23:53 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-25 22:58 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 07:34 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) olcott <NoOne@NoWhere.com> - 2021-03-26 10:13 -0500
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-26 19:51 -0400
Re: A UTM halt decider <is> a pure function of its inputs (undecidability basis) Richard Damon <Richard@Damon-Family.org> - 2021-03-25 21:43 -0400
Re: A UTM halt decider <is> a pure function of its inputs (last objection addressed) olcott <NoOne@NoWhere.com> - 2021-03-22 18:11 -0500
Re: A UTM halt decider <is> a pure function of its inputs (last objection addressed) André G. Isaak <agisaak@gm.invalid> - 2021-03-22 17:48 -0600
Re: A UTM halt decider <is> a pure function of its inputs (last objection addressed) olcott <NoOne@NoWhere.com> - 2021-03-22 19:19 -0500
Re: A UTM halt decider <is> a pure function of its inputs (kittens are purring) Richard Damon <Richard@Damon-Family.org> - 2021-03-19 13:46 -0400
Re: A UTM halt decider <is> a pure function of its inputs Richard Damon <Richard@Damon-Family.org> - 2021-03-18 07:17 -0400
Re: A UTM halt decider <is> a pure function of its inputs olcott <NoOne@NoWhere.com> - 2021-03-18 10:14 -0500
Re: A UTM halt decider <is> a pure function of its inputs Andy Walker <anw@cuboid.co.uk> - 2021-03-18 17:02 +0000
Re: A UTM halt decider <is> a pure function of its inputs olcott <NoOne@NoWhere.com> - 2021-03-18 12:58 -0500
Page 19 of 36 — ← Prev page 1 … 17 18 [19] 20 21 … 36 Next page →
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-30 08:04 -0400 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C) |
| Message-ID | <2tE8I.24883$GCH7.6564@fx17.iad> |
| In reply to | #30325 |
On 3/29/21 10:41 PM, olcott wrote: > On 3/29/2021 9:34 PM, Richard Damon wrote: >> On 3/29/21 10:12 PM, olcott wrote: >>> My halting function requires static local memory, if Turing machines >>> cannot simulate static local memory then the C language is strictly more >>> powerful that a Turing machine because a C function with static local >>> memory can keep track of its every invocation. >> >> Turing Machine CAN create the equivalent operation of static local >> memory, where that memory is accessible to that same computation. That >> keeps the operation to be a computation. >> >> A computation can NOT 'transfer' information via a back channel to >> another computation, even another copy of itself. Such transfer of >> information must be models as an explicit formal input. >> >> A C function with a local static variable, is in general NOT a >> computation by itself, unless that static variable is made a formal >> input. >> >> The FULL C program that it is part of, will normally be a computation >> (unless it is using some OS resource to get information not indicated as >> part of its input) >> > > A C function can detect when it is being called in infinite recursion > only when it can keep track of its prior invocations, if A Turing > machine cannot simulate this then the C function is strictly more > powerful than a TM because it can do something that a TM cannot do. > You seem to have this fatal flaw in your logic. Turing Machine represent FULL computations, your C function as described is a piece of a computation, not a full computation in itself. A Turing Machine can create the equivalent to the FULL computation you can build with this function, even if it can't represent the function by itself. Look at it this way, Can you run the code for Halts, BY ITS SELF, and get any answer, NO. You need to put it into a program that uses your x86utm. That means that this final program, including the x86utm is what becomes the Turing Machine. You can't claim that x86utm is 'just the os, so doesn't count' because Turing Machines aren't embedded within an OS, they are Free Standing Program.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-30 09:39 -0500 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C) |
| Message-ID | <hZidna9_jOmBpf79nZ2dnUU7-bHNnZ2d@giganews.com> |
| In reply to | #30336 |
On 3/30/2021 7:04 AM, Richard Damon wrote:
> On 3/29/21 10:41 PM, olcott wrote:
>> On 3/29/2021 9:34 PM, Richard Damon wrote:
>>> On 3/29/21 10:12 PM, olcott wrote:
>>>> My halting function requires static local memory, if Turing machines
>>>> cannot simulate static local memory then the C language is strictly more
>>>> powerful that a Turing machine because a C function with static local
>>>> memory can keep track of its every invocation.
>>>
>>> Turing Machine CAN create the equivalent operation of static local
>>> memory, where that memory is accessible to that same computation. That
>>> keeps the operation to be a computation.
>>>
>>> A computation can NOT 'transfer' information via a back channel to
>>> another computation, even another copy of itself. Such transfer of
>>> information must be models as an explicit formal input.
>>>
>>> A C function with a local static variable, is in general NOT a
>>> computation by itself, unless that static variable is made a formal
>>> input.
>>>
>>> The FULL C program that it is part of, will normally be a computation
>>> (unless it is using some OS resource to get information not indicated as
>>> part of its input)
>>>
>>
>> A C function can detect when it is being called in infinite recursion
>> only when it can keep track of its prior invocations, if A Turing
>> machine cannot simulate this then the C function is strictly more
>> powerful than a TM because it can do something that a TM cannot do.
>>
>
> You seem to have this fatal flaw in your logic.
>
> Turing Machine represent FULL computations, your C function as described
> is a piece of a computation, not a full computation in itself.
>
> A Turing Machine can create the equivalent to the FULL computation you
> can build with this function, even if it can't represent the function by
> itself.
>
A C function can detect that it was called in infinite recursion on the
basis of the stored execution traces of all of the times that it was
called:
u32 Halts(u32 P, u32 I)
{
static u32* execution_trace;
slave_state->EIP = P; // Function to invoke
while (!Aborted)
{
u32 EIP = slave_state->EIP; // Instruction to be executed
DebugStep(master_state, slave_state); // Execute this instruction
PushBack(local_execution_trace_list, EIP);
Aborted = Needs_To_Be_Aborted(execution_trace, (u32)Halts);
}
return 0; // Does not halt
END_OF_CODE: // Input has normally terminated
return 1;
}
This <is> a strict dichotomy:
(1) A TM can simulate the above computation thus detect when another TM
has invoked it in infinite recursion.
(2) The above C function is strictly more powerful than a TM.
Dodging this dichotomy is merely dodgy not any form of rebuttal.
https://www.merriam-webster.com/dictionary/dodgy
> Look at it this way, Can you run the code for Halts, BY ITS SELF, and
> get any answer, NO. You need to put it into a program that uses your
> x86utm. That means that this final program, including the x86utm is what
> becomes the Turing Machine.
>
> You can't claim that x86utm is 'just the os, so doesn't count' because
> Turing Machines aren't embedded within an OS, they are Free Standing
> Program.
Yes Turing machines that cannot possibly be halt decider are not
embedded within a OS. TMs that are halt deciders are the UTM OS that
correctly decides halting for its inputs.
--
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-30 15:21 +0000 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C) |
| Message-ID | <20210330080313.44@kylheku.com> |
| In reply to | #30346 |
On 2021-03-30, olcott <NoOne@NoWhere.com> wrote: > A C function can detect that it was called in infinite recursion on the > basis of the stored execution traces of all of the times that it was > called: Proofs of halting based on functions specifically rule out this sort of nonsense. They require pure functions. A pure function cannot have access to historic information about prior calls; that is absolutely ruled out. A function begins calculating in an a universe which only contains the arguments that have been given, and the body which specifies the calculations. That universe is otherwise empty. You will be laughed at if you approach academia with this nonsense. They will tell you that you are probably confused because C uses the word "function" for denoting all procedures, including ones that access mutating, global state. If you want to have a pure function which has information about something from before it was invoked, that information has to appear as a formal parameter. The caller has to supply it. Then, if you have a three-parameter H function, being called in two different places as H(H^, H^, X) and H(^H, H^, Y), you have to establish that X = Y. You have to hold that third parameter constant order to be able to say that the two places are the same function invocation. H(H^, H^, X) and H(H^, H^, Y) are not the same decision if X /= Y. Based on the third parameter, they could be completely different decider algorithms. You cannot refute the proof, because the proof requires two calls to the decider being absolutely the same for same values of two arguments. That's a key premise of the proof. To refute a proof, you must keep all the premises and show that the conclusion is false. To maintain the premise, if you add a third argument, it must be the same in both places, and not some constantly churning toilet bowl of global data. The proof doesn't claim that there is an undecidable test case against all deciders. If H^ "does the opposite" of what one decider says, like H(H^, H^, X), that can easily be decided correctly by another decider H(H^, H^, Y), where Y != X. That is not even slighly controversible. -- 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-30 10:42 -0500 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C) |
| Message-ID | <39CdnZqAkOdK2_79nZ2dnUU7-VfNnZ2d@giganews.com> |
| In reply to | #30351 |
On 3/30/2021 10:21 AM, Kaz Kylheku wrote: > On 2021-03-30, olcott <NoOne@NoWhere.com> wrote: >> A C function can detect that it was called in infinite recursion on the >> basis of the stored execution traces of all of the times that it was >> called: > > Proofs of halting based on functions specifically rule out this > sort of nonsense. > > They require pure functions. > > A pure function cannot have access to historic information > about prior calls; that is absolutely ruled out. In this same way we can make the undecidable dog walking problem: How do you walk your dog across the street when by what-ever-means that your dog arrives across the street is ruled as non-kosher thus does not count? > A function begins calculating in an a universe which only > contains the arguments that have been given, and the body which > specifies the calculations. That universe is otherwise empty. Then it begins simulating this input and deriving the intermediate internal state of the execution trace of each instruction that it simulates. If this code that it simulates begins simualating the simulator the first simulator keeps track of every single line of its own code that is simulated as well as all of the inputs to each one of these simulations. Every time that it simulates each instruction it performs halting analysis on this whole set of instructions. -- 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-30 15:59 +0000 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C) |
| Message-ID | <20210330085640.50@kylheku.com> |
| In reply to | #30356 |
On 2021-03-30, olcott <NoOne@NoWhere.com> wrote: > On 3/30/2021 10:21 AM, Kaz Kylheku wrote: >> On 2021-03-30, olcott <NoOne@NoWhere.com> wrote: >>> A C function can detect that it was called in infinite recursion on the >>> basis of the stored execution traces of all of the times that it was >>> called: >> >> Proofs of halting based on functions specifically rule out this >> sort of nonsense. >> >> They require pure functions. >> >> A pure function cannot have access to historic information >> about prior calls; that is absolutely ruled out. > > In this same way we can make the undecidable dog walking problem: > How do you walk your dog across the street when by what-ever-means that > your dog arrives across the street is ruled as non-kosher thus does not > count? The only valid dog analogy here is your whimpery whining. > >> A function begins calculating in an a universe which only >> contains the arguments that have been given, and the body which >> specifies the calculations. That universe is otherwise empty. > > Then it begins simulating this input and deriving the intermediate > internal state of the execution trace of each instruction that it > simulates. And that's fine. You must fix your program to the above, so that every call to the decider starts the simulation in a blank slate, with absolutely no sharing of any global variables between concurrently existing simulator instances. -- TXR Programming Language: http://nongnu.org/txr Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-30 12:20 -0400 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C) |
| Message-ID | <pdI8I.78981$t66.76019@fx38.iad> |
| In reply to | #30346 |
On 3/30/21 10:39 AM, olcott wrote:
> On 3/30/2021 7:04 AM, Richard Damon wrote:
>> On 3/29/21 10:41 PM, olcott wrote:
>>> On 3/29/2021 9:34 PM, Richard Damon wrote:
>>>> On 3/29/21 10:12 PM, olcott wrote:
>>>>> My halting function requires static local memory, if Turing machines
>>>>> cannot simulate static local memory then the C language is strictly
>>>>> more
>>>>> powerful that a Turing machine because a C function with static local
>>>>> memory can keep track of its every invocation.
>>>>
>>>> Turing Machine CAN create the equivalent operation of static local
>>>> memory, where that memory is accessible to that same computation. That
>>>> keeps the operation to be a computation.
>>>>
>>>> A computation can NOT 'transfer' information via a back channel to
>>>> another computation, even another copy of itself. Such transfer of
>>>> information must be models as an explicit formal input.
>>>>
>>>> A C function with a local static variable, is in general NOT a
>>>> computation by itself, unless that static variable is made a formal
>>>> input.
>>>>
>>>> The FULL C program that it is part of, will normally be a computation
>>>> (unless it is using some OS resource to get information not
>>>> indicated as
>>>> part of its input)
>>>>
>>>
>>> A C function can detect when it is being called in infinite recursion
>>> only when it can keep track of its prior invocations, if A Turing
>>> machine cannot simulate this then the C function is strictly more
>>> powerful than a TM because it can do something that a TM cannot do.
>>>
>>
>> You seem to have this fatal flaw in your logic.
>>
>> Turing Machine represent FULL computations, your C function as described
>> is a piece of a computation, not a full computation in itself.
>>
>> A Turing Machine can create the equivalent to the FULL computation you
>> can build with this function, even if it can't represent the function by
>> itself.
>>
>
>
> A C function can detect that it was called in infinite recursion on the
> basis of the stored execution traces of all of the times that it was
> called:
>
> u32 Halts(u32 P, u32 I)
> {
> static u32* execution_trace;
> slave_state->EIP = P; // Function to invoke
> while (!Aborted)
> {
> u32 EIP = slave_state->EIP; // Instruction to be executed
> DebugStep(master_state, slave_state); // Execute this instruction
> PushBack(local_execution_trace_list, EIP);
> Aborted = Needs_To_Be_Aborted(execution_trace, (u32)Halts);
> }
> return 0; // Does not halt
> END_OF_CODE: // Input has normally terminated
> return 1;
> }
>
> This <is> a strict dichotomy:
> (1) A TM can simulate the above computation thus detect when another TM
> has invoked it in infinite recursion.
>
> (2) The above C function is strictly more powerful than a TM.
>
> Dodging this dichotomy is merely dodgy not any form of rebuttal.
> https://www.merriam-webster.com/dictionary/dodgy
>
>> Look at it this way, Can you run the code for Halts, BY ITS SELF, and
>> get any answer, NO. You need to put it into a program that uses your
>> x86utm. That means that this final program, including the x86utm is what
>> becomes the Turing Machine.
>>
>> You can't claim that x86utm is 'just the os, so doesn't count' because
>> Turing Machines aren't embedded within an OS, they are Free Standing
>> Program.
>
> Yes Turing machines that cannot possibly be halt decider are not
> embedded within a OS. TMs that are halt deciders are the UTM OS that
> correctly decides halting for its inputs.
>
>
You show a TOTAL lack of understanding of Computations.
Halts, without the OS, can't do anything, you can't run it. Halts
combined with the OS forms a computation, which can become a Turing
Machine. That Turing Machine includes the OS inside it, so H^ will be
outside that OS.
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-03-29 21:25 -0600 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (Computability!) |
| Message-ID | <s3u5mr$7va$1@dont-email.me> |
| In reply to | #30316 |
On 2021-03-29 20:12, olcott wrote:
> On 3/29/2021 9:06 PM, André G. Isaak wrote:
>> On 2021-03-29 19:48, olcott wrote:
>>> On 3/29/2021 8:25 PM, André G. Isaak wrote:
>>>> On 2021-03-29 19:22, olcott wrote:
>>>>> On 3/29/2021 7:41 PM, André G. Isaak wrote:
>>>>>> On 2021-03-29 16:42, olcott wrote:
>>>>>>> On 3/29/2021 4:36 PM, André G. Isaak wrote:
>>>>>>>> On 2021-03-29 14:57, olcott wrote:
>>>>>>>>> On 3/29/2021 3:10 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-03-29 14:00, olcott wrote:
>>>>>>>>>>> On 3/29/2021 12:43 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-03-29 10:53, olcott wrote:
>>>>>>>>>>>>> On 3/29/2021 11:45 AM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-03-28 19:26, olcott wrote:
>>>>>>>>>>>>>>> On 3/28/2021 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/28/21 8:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/28/2021 6:34 PM, Andy Walker wrote:
>>>>>>>>>>>>>>>>>> On 28/03/2021 23:38, olcott wrote:
>>>>>>>>>>>>>>>>>> [I wrote:]
>>>>>>>>>>>>>>>>>>>> [...] Let us know when you have an "H" and its
>>>>>>>>>>>>>>>>>>>> corresponding
>>>>>>>>>>>>>>>>>>>> /correct/ "H_hat", without all the flannel about
>>>>>>>>>>>>>>>>>>>> UTMs, inner and outer
>>>>>>>>>>>>>>>>>>>> invocations, recursion and so on, and can tell us
>>>>>>>>>>>>>>>>>>>> what they do.
>>>>>>>>>>>>>>>>>>> To define an H that correctly decides H^ inherently
>>>>>>>>>>>>>>>>>>> requires that H
>>>>>>>>>>>>>>>>>>> be defined on the basis of a UTM that detects that
>>>>>>>>>>>>>>>>>>> itself has been
>>>>>>>>>>>>>>>>>>> invoked in infinite recursion.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> There is no such requirement, inherent or
>>>>>>>>>>>>>>>>>> otherwise; that is
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except for the fact that every other alternative can't
>>>>>>>>>>>>>>>>> possibly work...
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Who says it has to work? Your arguement has the falicy
>>>>>>>>>>>>>>>> of assuming the
>>>>>>>>>>>>>>>> conclusion.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> entirely down to how you choose to write "H".
>>>>>>>>>>>>>>>>>> However, once you have
>>>>>>>>>>>>>>>>>> written "H", then by the definition of "H_hat" it
>>>>>>>>>>>>>>>>>> incorrectly decides
>>>>>>>>>>>>>>>>>> the nature of "H_hat". But you need to write "H"
>>>>>>>>>>>>>>>>>> /first/, including
>>>>>>>>>>>>>>>>>> any "operating system" requirements that it has [which
>>>>>>>>>>>>>>>>>> must then be
>>>>>>>>>>>>>>>>>> included in "H_hat"].
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H only needs to be able to simulate its input
>>>>>>>>>>>>>>>>> one-instruction-at-a-time,
>>>>>>>>>>>>>>>>> keep a set of execution traces of this simulation,
>>>>>>>>>>>>>>>>> examine each trace
>>>>>>>>>>>>>>>>> after each instruction is simulated
>>>>>>>>>>>>>>>>> one-instruction-at-a-time, and
>>>>>>>>>>>>>>>>> detect when H^ calls H from the same machine address
>>>>>>>>>>>>>>>>> twice with no
>>>>>>>>>>>>>>>>> conditional branch instructions inbetween.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> To say that this is uncomputable is ridiculous.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We are saying it doesn't match the defintion of a Pure
>>>>>>>>>>>>>>>> Computaiton.
>>>>>>>>>>>>>>>> Primarily because due to your 'global' system, it gets
>>>>>>>>>>>>>>>> information
>>>>>>>>>>>>>>>> beyond its formal inputs. Build your system with just
>>>>>>>>>>>>>>>> the local decider
>>>>>>>>>>>>>>>> and you can get around that issue.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That may be the best approach, yet people are confused by
>>>>>>>>>>>>>>> that one too.
>>>>>>>>>>>>>>> To get around their confusion:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We can simply forget all about H^ and simply have Halts
>>>>>>>>>>>>>>> decide halting on itself as a valid proxy for Halts
>>>>>>>>>>>>>>> deciding halting on H^.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because Halts decides that itself would be infinitely
>>>>>>>>>>>>>>> recursive unless it aborted itself it is obvious that
>>>>>>>>>>>>>>> appending some infinite loop states at the its end won't
>>>>>>>>>>>>>>> change this correct halting decision.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If the only information that Halts
>>>>>>>>>>>>>>>> uses is what happens after the call to it, then you are
>>>>>>>>>>>>>>>> good there. You
>>>>>>>>>>>>>>>> also need to remove the Halt Decider around main, that
>>>>>>>>>>>>>>>> doesn't exist in
>>>>>>>>>>>>>>>> the proofs you are looking at, and make your system no
>>>>>>>>>>>>>>>> longer Turing
>>>>>>>>>>>>>>>> Complete.
>>>>>>>>>>>>>>> I don't need that when I drop H^ and use the Halts proxy
>>>>>>>>>>>>>>> mentioned above.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I still must have a static local or a global that does
>>>>>>>>>>>>>>> not immediately forget about all of the preceding
>>>>>>>>>>>>>>> execution traces.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But, as has been pointed out, as soon as you start making
>>>>>>>>>>>>>> use of persistent variables within your embedded call to
>>>>>>>>>>>>>> H(^) you are no longer dealing with a computation. If your
>>>>>>>>>>>>>> embedded H(^) isn't a computation, it has no corresponding
>>>>>>>>>>>>>> Turing Machine, which means you aren't addressing the
>>>>>>>>>>>>>> actual proofs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That does not effect the correctness of my halt decider
>>>>>>>>>>>>> which is a pure function of finite strings to final states.
>>>>>>>>>>>>
>>>>>>>>>>>> It *isn't* a pure function. That's the whole point.
>>>>>>>>>>
>>>>>>>>>> Possibly, but the halting problem takes a description of a
>>>>>>>>>> Turing Machine as its input, and the function which you are
>>>>>>>>>> passing as an input is *not* a pure function. For whatever it
>>>>>>>>>> is that you're doing to have any relevance whatsoever to the
>>>>>>>>>> actual Halting Problem, you need the function which you pass
>>>>>>>>>> as an input to your 'global decider' to be a pure function.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The global halt decider is a pure function of finite strings to
>>>>>>>>> final states. If for whatever reason an undecidable input
>>>>>>>>> cannot possibly be properly defined then the conventional
>>>>>>>>> proofs have been refuted.
>>>>>>>>
>>>>>>>> There are no 'undecidable inputs' to the halting problem, only
>>>>>>>> inputs that might be undecidable by a particular machine. No one
>>>>>>>> has claimed that the input which fails on your machine cannot be
>>>>>>>> properly defined (i.e. defined as pure computation), only that
>>>>>>>> *you* have failed to do so.
>>>>>>>>
>>>>>>>> Right now your H_Hat is not a pure computation. If your global
>>>>>>>> decider is indeed a pure computation, then you can easily define
>>>>>>>> an H_Hat which *is* a pure computation -- simply use the method
>>>>>>>> outlined in Linz. You, however, refuse to do this.
>>>>>>>>
>>>>>>>> If you do actually do this, you will discover that your global
>>>>>>>> decider will fail to correctly decide H_Hat.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> An x86 function can detect when it is being called in infinite
>>>>>>> recursion if a Turing machine cannot do this same thing then we
>>>>>>> must conclude that x86 functions are strictly more powerful than
>>>>>>> Turing machines and Church-Turing has been refuted.
>>>>>>
>>>>>> It can detect relatively trivial instances of infinite recursion.
>>>>>> But what does this have to do with the observation that your input
>>>>>> to Halts() is not a pure function?
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> An x86 function that can detect that it was called in infinite
>>>>> recursion cannot possibly do this if it is required to forget
>>>>> everything about all of its prior invocations.
>>>>
>>>> And a Turing machine *always* forgets everything about all its prior
>>>> invocations. So you are basically admitting that your alleged
>>>> solution won't work for actual Turing Machines.
>>>>
>>>>
>>>
>>> If I am "admitting" this then I am also "admitting" that x86
>>> functions have proven to be strictly more powerful than Turing
>>> machines because they can do something that Turing machine cannot do.
>>
>> An x86 program forgets everything about its prior invocations just as
>> much as a Turing Machine does.
>
> My halting function requires static local memory, if Turing machines
> cannot simulate static local memory then the C language is strictly more
> powerful that a Turing machine because a C function with static local
> memory can keep track of its every invocation.
You're really not event trying to get this, are you? A function using
static variables is *not* a computation because the value of that
variable provides additional input to the computation which is not
explicitly declared. That doesn't say anything about C being more
powerful than Turing Machines. The following is not a computation due to
the static variable.
int foo(void) {
static int x;
...
}
However, it can be made into a computation by making that additional
input explicit as follows:
int fooComputation(int x) {
...
}
If you don't do the above, the entire program in which foo is embedded
will still likely constitute a computation.
A Turing Machine can be constructed which performs the same calculation
as fooComputation(), or the entire program in which foo() is embedded.
You simply can't make a Turing Machine which does what foo() does
because foo() is not a computation.
The problem which you face is that a halt decider evaluates a
*computation* to determine whether it halts. That means that any
function you pass to your Halts() must be a function which represents a
an actual computation.
By using static variables in Halts(), you preclude Halts() from being
used as an input to Halts or from being the basis of H_Hat.
You need therefore to construct H_Hat from your entire program, since
that will be a computation. Not just some subroutine which doesn't
represent a computation on its own. And H_Hat must include a complete
copy of the program. It can't call on routines from the original program.
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-29 22:38 -0500 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) |
| Message-ID | <yLOdne4aHsnbAP_9nZ2dnUU7-d3NnZ2d@giganews.com> |
| In reply to | #30327 |
On 3/29/2021 10:25 PM, André G. Isaak wrote:
> On 2021-03-29 20:12, olcott wrote:
>> On 3/29/2021 9:06 PM, André G. Isaak wrote:
>>> On 2021-03-29 19:48, olcott wrote:
>>>> On 3/29/2021 8:25 PM, André G. Isaak wrote:
>>>>> On 2021-03-29 19:22, olcott wrote:
>>>>>> On 3/29/2021 7:41 PM, André G. Isaak wrote:
>>>>>>> On 2021-03-29 16:42, olcott wrote:
>>>>>>>> On 3/29/2021 4:36 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-03-29 14:57, olcott wrote:
>>>>>>>>>> On 3/29/2021 3:10 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-03-29 14:00, olcott wrote:
>>>>>>>>>>>> On 3/29/2021 12:43 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-03-29 10:53, olcott wrote:
>>>>>>>>>>>>>> On 3/29/2021 11:45 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2021-03-28 19:26, olcott wrote:
>>>>>>>>>>>>>>>> On 3/28/2021 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/28/21 8:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/28/2021 6:34 PM, Andy Walker wrote:
>>>>>>>>>>>>>>>>>>> On 28/03/2021 23:38, olcott wrote:
>>>>>>>>>>>>>>>>>>> [I wrote:]
>>>>>>>>>>>>>>>>>>>>> [...] Let us know when you have an "H" and its
>>>>>>>>>>>>>>>>>>>>> corresponding
>>>>>>>>>>>>>>>>>>>>> /correct/ "H_hat", without all the flannel about
>>>>>>>>>>>>>>>>>>>>> UTMs, inner and outer
>>>>>>>>>>>>>>>>>>>>> invocations, recursion and so on, and can tell us
>>>>>>>>>>>>>>>>>>>>> what they do.
>>>>>>>>>>>>>>>>>>>> To define an H that correctly decides H^ inherently
>>>>>>>>>>>>>>>>>>>> requires that H
>>>>>>>>>>>>>>>>>>>> be defined on the basis of a UTM that detects that
>>>>>>>>>>>>>>>>>>>> itself has been
>>>>>>>>>>>>>>>>>>>> invoked in infinite recursion.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> There is no such requirement, inherent or
>>>>>>>>>>>>>>>>>>> otherwise; that is
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except for the fact that every other alternative can't
>>>>>>>>>>>>>>>>>> possibly work...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Who says it has to work? Your arguement has the falicy
>>>>>>>>>>>>>>>>> of assuming the
>>>>>>>>>>>>>>>>> conclusion.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> entirely down to how you choose to write "H".
>>>>>>>>>>>>>>>>>>> However, once you have
>>>>>>>>>>>>>>>>>>> written "H", then by the definition of "H_hat" it
>>>>>>>>>>>>>>>>>>> incorrectly decides
>>>>>>>>>>>>>>>>>>> the nature of "H_hat". But you need to write "H"
>>>>>>>>>>>>>>>>>>> /first/, including
>>>>>>>>>>>>>>>>>>> any "operating system" requirements that it has
>>>>>>>>>>>>>>>>>>> [which must then be
>>>>>>>>>>>>>>>>>>> included in "H_hat"].
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H only needs to be able to simulate its input
>>>>>>>>>>>>>>>>>> one-instruction-at-a-time,
>>>>>>>>>>>>>>>>>> keep a set of execution traces of this simulation,
>>>>>>>>>>>>>>>>>> examine each trace
>>>>>>>>>>>>>>>>>> after each instruction is simulated
>>>>>>>>>>>>>>>>>> one-instruction-at-a-time, and
>>>>>>>>>>>>>>>>>> detect when H^ calls H from the same machine address
>>>>>>>>>>>>>>>>>> twice with no
>>>>>>>>>>>>>>>>>> conditional branch instructions inbetween.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> To say that this is uncomputable is ridiculous.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We are saying it doesn't match the defintion of a Pure
>>>>>>>>>>>>>>>>> Computaiton.
>>>>>>>>>>>>>>>>> Primarily because due to your 'global' system, it gets
>>>>>>>>>>>>>>>>> information
>>>>>>>>>>>>>>>>> beyond its formal inputs. Build your system with just
>>>>>>>>>>>>>>>>> the local decider
>>>>>>>>>>>>>>>>> and you can get around that issue.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That may be the best approach, yet people are confused
>>>>>>>>>>>>>>>> by that one too.
>>>>>>>>>>>>>>>> To get around their confusion:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We can simply forget all about H^ and simply have Halts
>>>>>>>>>>>>>>>> decide halting on itself as a valid proxy for Halts
>>>>>>>>>>>>>>>> deciding halting on H^.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because Halts decides that itself would be infinitely
>>>>>>>>>>>>>>>> recursive unless it aborted itself it is obvious that
>>>>>>>>>>>>>>>> appending some infinite loop states at the its end won't
>>>>>>>>>>>>>>>> change this correct halting decision.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If the only information that Halts
>>>>>>>>>>>>>>>>> uses is what happens after the call to it, then you are
>>>>>>>>>>>>>>>>> good there. You
>>>>>>>>>>>>>>>>> also need to remove the Halt Decider around main, that
>>>>>>>>>>>>>>>>> doesn't exist in
>>>>>>>>>>>>>>>>> the proofs you are looking at, and make your system no
>>>>>>>>>>>>>>>>> longer Turing
>>>>>>>>>>>>>>>>> Complete.
>>>>>>>>>>>>>>>> I don't need that when I drop H^ and use the Halts proxy
>>>>>>>>>>>>>>>> mentioned above.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I still must have a static local or a global that does
>>>>>>>>>>>>>>>> not immediately forget about all of the preceding
>>>>>>>>>>>>>>>> execution traces.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But, as has been pointed out, as soon as you start making
>>>>>>>>>>>>>>> use of persistent variables within your embedded call to
>>>>>>>>>>>>>>> H(^) you are no longer dealing with a computation. If
>>>>>>>>>>>>>>> your embedded H(^) isn't a computation, it has no
>>>>>>>>>>>>>>> corresponding Turing Machine, which means you aren't
>>>>>>>>>>>>>>> addressing the actual proofs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That does not effect the correctness of my halt decider
>>>>>>>>>>>>>> which is a pure function of finite strings to final states.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It *isn't* a pure function. That's the whole point.
>>>>>>>>>>>
>>>>>>>>>>> Possibly, but the halting problem takes a description of a
>>>>>>>>>>> Turing Machine as its input, and the function which you are
>>>>>>>>>>> passing as an input is *not* a pure function. For whatever it
>>>>>>>>>>> is that you're doing to have any relevance whatsoever to the
>>>>>>>>>>> actual Halting Problem, you need the function which you pass
>>>>>>>>>>> as an input to your 'global decider' to be a pure function.
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The global halt decider is a pure function of finite strings
>>>>>>>>>> to final states. If for whatever reason an undecidable input
>>>>>>>>>> cannot possibly be properly defined then the conventional
>>>>>>>>>> proofs have been refuted.
>>>>>>>>>
>>>>>>>>> There are no 'undecidable inputs' to the halting problem, only
>>>>>>>>> inputs that might be undecidable by a particular machine. No
>>>>>>>>> one has claimed that the input which fails on your machine
>>>>>>>>> cannot be properly defined (i.e. defined as pure computation),
>>>>>>>>> only that *you* have failed to do so.
>>>>>>>>>
>>>>>>>>> Right now your H_Hat is not a pure computation. If your global
>>>>>>>>> decider is indeed a pure computation, then you can easily
>>>>>>>>> define an H_Hat which *is* a pure computation -- simply use the
>>>>>>>>> method outlined in Linz. You, however, refuse to do this.
>>>>>>>>>
>>>>>>>>> If you do actually do this, you will discover that your global
>>>>>>>>> decider will fail to correctly decide H_Hat.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> An x86 function can detect when it is being called in infinite
>>>>>>>> recursion if a Turing machine cannot do this same thing then we
>>>>>>>> must conclude that x86 functions are strictly more powerful than
>>>>>>>> Turing machines and Church-Turing has been refuted.
>>>>>>>
>>>>>>> It can detect relatively trivial instances of infinite recursion.
>>>>>>> But what does this have to do with the observation that your
>>>>>>> input to Halts() is not a pure function?
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> An x86 function that can detect that it was called in infinite
>>>>>> recursion cannot possibly do this if it is required to forget
>>>>>> everything about all of its prior invocations.
>>>>>
>>>>> And a Turing machine *always* forgets everything about all its
>>>>> prior invocations. So you are basically admitting that your alleged
>>>>> solution won't work for actual Turing Machines.
>>>>>
>>>>>
>>>>
>>>> If I am "admitting" this then I am also "admitting" that x86
>>>> functions have proven to be strictly more powerful than Turing
>>>> machines because they can do something that Turing machine cannot do.
>>>
>>> An x86 program forgets everything about its prior invocations just as
>>> much as a Turing Machine does.
>>
>> My halting function requires static local memory, if Turing machines
>> cannot simulate static local memory then the C language is strictly
>> more powerful that a Turing machine because a C function with static
>> local memory can keep track of its every invocation.
>
> You're really not event trying to get this, are you? A function using
> static variables is *not* a computation because the value of that
> variable provides additional input to the computation which is not
> explicitly declared. That doesn't say anything about C being more
> powerful than Turing Machines. The following is not a computation due to
> the static variable.
The TM has to do this:
u32 Halts(u32 P, u32 I)
{
static u32* execution_trace;
slave_state->EIP = P; // Function to invoke
while (!Aborted)
{
u32 EIP = slave_state->EIP; // Instruction to be executed
DebugStep(master_state, slave_state); // Execute this instruction
PushBack(local_execution_trace_list, EIP);
Aborted = Needs_To_Be_Aborted(execution_trace, (u32)Halts);
}
return 0; // Does not halt
END_OF_CODE: // Input has normally terminated
return 1;
}
--
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-29 22:11 -0600 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) |
| Message-ID | <s3u8dk$ld1$1@dont-email.me> |
| In reply to | #30328 |
On 2021-03-29 21:38, olcott wrote:
> On 3/29/2021 10:25 PM, André G. Isaak wrote:
>> On 2021-03-29 20:12, olcott wrote:
>>> On 3/29/2021 9:06 PM, André G. Isaak wrote:
>>>> On 2021-03-29 19:48, olcott wrote:
>>>>> On 3/29/2021 8:25 PM, André G. Isaak wrote:
>>>>>> On 2021-03-29 19:22, olcott wrote:
>>>>>>> On 3/29/2021 7:41 PM, André G. Isaak wrote:
>>>>>>>> On 2021-03-29 16:42, olcott wrote:
>>>>>>>>> On 3/29/2021 4:36 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-03-29 14:57, olcott wrote:
>>>>>>>>>>> On 3/29/2021 3:10 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-03-29 14:00, olcott wrote:
>>>>>>>>>>>>> On 3/29/2021 12:43 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-03-29 10:53, olcott wrote:
>>>>>>>>>>>>>>> On 3/29/2021 11:45 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>> On 2021-03-28 19:26, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/28/2021 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/28/21 8:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/28/2021 6:34 PM, Andy Walker wrote:
>>>>>>>>>>>>>>>>>>>> On 28/03/2021 23:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>> [I wrote:]
>>>>>>>>>>>>>>>>>>>>>> [...] Let us know when you have an "H" and its
>>>>>>>>>>>>>>>>>>>>>> corresponding
>>>>>>>>>>>>>>>>>>>>>> /correct/ "H_hat", without all the flannel about
>>>>>>>>>>>>>>>>>>>>>> UTMs, inner and outer
>>>>>>>>>>>>>>>>>>>>>> invocations, recursion and so on, and can tell us
>>>>>>>>>>>>>>>>>>>>>> what they do.
>>>>>>>>>>>>>>>>>>>>> To define an H that correctly decides H^ inherently
>>>>>>>>>>>>>>>>>>>>> requires that H
>>>>>>>>>>>>>>>>>>>>> be defined on the basis of a UTM that detects that
>>>>>>>>>>>>>>>>>>>>> itself has been
>>>>>>>>>>>>>>>>>>>>> invoked in infinite recursion.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> There is no such requirement, inherent or
>>>>>>>>>>>>>>>>>>>> otherwise; that is
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except for the fact that every other alternative
>>>>>>>>>>>>>>>>>>> can't possibly work...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Who says it has to work? Your arguement has the falicy
>>>>>>>>>>>>>>>>>> of assuming the
>>>>>>>>>>>>>>>>>> conclusion.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> entirely down to how you choose to write "H".
>>>>>>>>>>>>>>>>>>>> However, once you have
>>>>>>>>>>>>>>>>>>>> written "H", then by the definition of "H_hat" it
>>>>>>>>>>>>>>>>>>>> incorrectly decides
>>>>>>>>>>>>>>>>>>>> the nature of "H_hat". But you need to write "H"
>>>>>>>>>>>>>>>>>>>> /first/, including
>>>>>>>>>>>>>>>>>>>> any "operating system" requirements that it has
>>>>>>>>>>>>>>>>>>>> [which must then be
>>>>>>>>>>>>>>>>>>>> included in "H_hat"].
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H only needs to be able to simulate its input
>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time,
>>>>>>>>>>>>>>>>>>> keep a set of execution traces of this simulation,
>>>>>>>>>>>>>>>>>>> examine each trace
>>>>>>>>>>>>>>>>>>> after each instruction is simulated
>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time, and
>>>>>>>>>>>>>>>>>>> detect when H^ calls H from the same machine address
>>>>>>>>>>>>>>>>>>> twice with no
>>>>>>>>>>>>>>>>>>> conditional branch instructions inbetween.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> To say that this is uncomputable is ridiculous.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We are saying it doesn't match the defintion of a Pure
>>>>>>>>>>>>>>>>>> Computaiton.
>>>>>>>>>>>>>>>>>> Primarily because due to your 'global' system, it gets
>>>>>>>>>>>>>>>>>> information
>>>>>>>>>>>>>>>>>> beyond its formal inputs. Build your system with just
>>>>>>>>>>>>>>>>>> the local decider
>>>>>>>>>>>>>>>>>> and you can get around that issue.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That may be the best approach, yet people are confused
>>>>>>>>>>>>>>>>> by that one too.
>>>>>>>>>>>>>>>>> To get around their confusion:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We can simply forget all about H^ and simply have Halts
>>>>>>>>>>>>>>>>> decide halting on itself as a valid proxy for Halts
>>>>>>>>>>>>>>>>> deciding halting on H^.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because Halts decides that itself would be infinitely
>>>>>>>>>>>>>>>>> recursive unless it aborted itself it is obvious that
>>>>>>>>>>>>>>>>> appending some infinite loop states at the its end
>>>>>>>>>>>>>>>>> won't change this correct halting decision.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If the only information that Halts
>>>>>>>>>>>>>>>>>> uses is what happens after the call to it, then you
>>>>>>>>>>>>>>>>>> are good there. You
>>>>>>>>>>>>>>>>>> also need to remove the Halt Decider around main, that
>>>>>>>>>>>>>>>>>> doesn't exist in
>>>>>>>>>>>>>>>>>> the proofs you are looking at, and make your system no
>>>>>>>>>>>>>>>>>> longer Turing
>>>>>>>>>>>>>>>>>> Complete.
>>>>>>>>>>>>>>>>> I don't need that when I drop H^ and use the Halts
>>>>>>>>>>>>>>>>> proxy mentioned above.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I still must have a static local or a global that does
>>>>>>>>>>>>>>>>> not immediately forget about all of the preceding
>>>>>>>>>>>>>>>>> execution traces.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But, as has been pointed out, as soon as you start
>>>>>>>>>>>>>>>> making use of persistent variables within your embedded
>>>>>>>>>>>>>>>> call to H(^) you are no longer dealing with a
>>>>>>>>>>>>>>>> computation. If your embedded H(^) isn't a computation,
>>>>>>>>>>>>>>>> it has no corresponding Turing Machine, which means you
>>>>>>>>>>>>>>>> aren't addressing the actual proofs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That does not effect the correctness of my halt decider
>>>>>>>>>>>>>>> which is a pure function of finite strings to final states.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It *isn't* a pure function. That's the whole point.
>>>>>>>>>>>>
>>>>>>>>>>>> Possibly, but the halting problem takes a description of a
>>>>>>>>>>>> Turing Machine as its input, and the function which you are
>>>>>>>>>>>> passing as an input is *not* a pure function. For whatever
>>>>>>>>>>>> it is that you're doing to have any relevance whatsoever to
>>>>>>>>>>>> the actual Halting Problem, you need the function which you
>>>>>>>>>>>> pass as an input to your 'global decider' to be a pure
>>>>>>>>>>>> function.
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The global halt decider is a pure function of finite strings
>>>>>>>>>>> to final states. If for whatever reason an undecidable input
>>>>>>>>>>> cannot possibly be properly defined then the conventional
>>>>>>>>>>> proofs have been refuted.
>>>>>>>>>>
>>>>>>>>>> There are no 'undecidable inputs' to the halting problem, only
>>>>>>>>>> inputs that might be undecidable by a particular machine. No
>>>>>>>>>> one has claimed that the input which fails on your machine
>>>>>>>>>> cannot be properly defined (i.e. defined as pure computation),
>>>>>>>>>> only that *you* have failed to do so.
>>>>>>>>>>
>>>>>>>>>> Right now your H_Hat is not a pure computation. If your global
>>>>>>>>>> decider is indeed a pure computation, then you can easily
>>>>>>>>>> define an H_Hat which *is* a pure computation -- simply use
>>>>>>>>>> the method outlined in Linz. You, however, refuse to do this.
>>>>>>>>>>
>>>>>>>>>> If you do actually do this, you will discover that your global
>>>>>>>>>> decider will fail to correctly decide H_Hat.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> An x86 function can detect when it is being called in infinite
>>>>>>>>> recursion if a Turing machine cannot do this same thing then we
>>>>>>>>> must conclude that x86 functions are strictly more powerful
>>>>>>>>> than Turing machines and Church-Turing has been refuted.
>>>>>>>>
>>>>>>>> It can detect relatively trivial instances of infinite
>>>>>>>> recursion. But what does this have to do with the observation
>>>>>>>> that your input to Halts() is not a pure function?
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> An x86 function that can detect that it was called in infinite
>>>>>>> recursion cannot possibly do this if it is required to forget
>>>>>>> everything about all of its prior invocations.
>>>>>>
>>>>>> And a Turing machine *always* forgets everything about all its
>>>>>> prior invocations. So you are basically admitting that your
>>>>>> alleged solution won't work for actual Turing Machines.
>>>>>>
>>>>>>
>>>>>
>>>>> If I am "admitting" this then I am also "admitting" that x86
>>>>> functions have proven to be strictly more powerful than Turing
>>>>> machines because they can do something that Turing machine cannot do.
>>>>
>>>> An x86 program forgets everything about its prior invocations just
>>>> as much as a Turing Machine does.
>>>
>>> My halting function requires static local memory, if Turing machines
>>> cannot simulate static local memory then the C language is strictly
>>> more powerful that a Turing machine because a C function with static
>>> local memory can keep track of its every invocation.
>>
>> You're really not event trying to get this, are you? A function using
>> static variables is *not* a computation because the value of that
>> variable provides additional input to the computation which is not
>> explicitly declared. That doesn't say anything about C being more
>> powerful than Turing Machines. The following is not a computation due
>> to the static variable.
>
> The TM has to do this:
And if it does that, it can't be realized as a TM, so quit calling it
one. You need to pass execution_trace as an explicit variable if you
want to do that in a TM, but then you are no longer talking about the H
of Linz since that TM takes only two arguments, not three.
André
> u32 Halts(u32 P, u32 I)
> {
> static u32* execution_trace;
> slave_state->EIP = P; // Function to invoke
> while (!Aborted)
> {
> u32 EIP = slave_state->EIP; // Instruction to be executed
> DebugStep(master_state, slave_state); // Execute this instruction
> PushBack(local_execution_trace_list, EIP);
> Aborted = Needs_To_Be_Aborted(execution_trace, (u32)Halts);
> }
> return 0; // Does not halt
> END_OF_CODE: // Input has normally terminated
> return 1;
> }
>
>
>
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-29 23:24 -0500 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) |
| Message-ID | <npCdnY-KKuuQNf_9nZ2dnUU7-WnNnZ2d@giganews.com> |
| In reply to | #30331 |
On 3/29/2021 11:11 PM, André G. Isaak wrote:
> On 2021-03-29 21:38, olcott wrote:
>> On 3/29/2021 10:25 PM, André G. Isaak wrote:
>>> On 2021-03-29 20:12, olcott wrote:
>>>> On 3/29/2021 9:06 PM, André G. Isaak wrote:
>>>>> On 2021-03-29 19:48, olcott wrote:
>>>>>> On 3/29/2021 8:25 PM, André G. Isaak wrote:
>>>>>>> On 2021-03-29 19:22, olcott wrote:
>>>>>>>> On 3/29/2021 7:41 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-03-29 16:42, olcott wrote:
>>>>>>>>>> On 3/29/2021 4:36 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-03-29 14:57, olcott wrote:
>>>>>>>>>>>> On 3/29/2021 3:10 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-03-29 14:00, olcott wrote:
>>>>>>>>>>>>>> On 3/29/2021 12:43 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2021-03-29 10:53, olcott wrote:
>>>>>>>>>>>>>>>> On 3/29/2021 11:45 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>> On 2021-03-28 19:26, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/28/2021 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/28/21 8:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/28/2021 6:34 PM, Andy Walker wrote:
>>>>>>>>>>>>>>>>>>>>> On 28/03/2021 23:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> [I wrote:]
>>>>>>>>>>>>>>>>>>>>>>> [...] Let us know when you have an "H" and its
>>>>>>>>>>>>>>>>>>>>>>> corresponding
>>>>>>>>>>>>>>>>>>>>>>> /correct/ "H_hat", without all the flannel about
>>>>>>>>>>>>>>>>>>>>>>> UTMs, inner and outer
>>>>>>>>>>>>>>>>>>>>>>> invocations, recursion and so on, and can tell us
>>>>>>>>>>>>>>>>>>>>>>> what they do.
>>>>>>>>>>>>>>>>>>>>>> To define an H that correctly decides H^
>>>>>>>>>>>>>>>>>>>>>> inherently requires that H
>>>>>>>>>>>>>>>>>>>>>> be defined on the basis of a UTM that detects that
>>>>>>>>>>>>>>>>>>>>>> itself has been
>>>>>>>>>>>>>>>>>>>>>> invoked in infinite recursion.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> There is no such requirement, inherent or
>>>>>>>>>>>>>>>>>>>>> otherwise; that is
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except for the fact that every other alternative
>>>>>>>>>>>>>>>>>>>> can't possibly work...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Who says it has to work? Your arguement has the
>>>>>>>>>>>>>>>>>>> falicy of assuming the
>>>>>>>>>>>>>>>>>>> conclusion.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> entirely down to how you choose to write "H".
>>>>>>>>>>>>>>>>>>>>> However, once you have
>>>>>>>>>>>>>>>>>>>>> written "H", then by the definition of "H_hat" it
>>>>>>>>>>>>>>>>>>>>> incorrectly decides
>>>>>>>>>>>>>>>>>>>>> the nature of "H_hat". But you need to write "H"
>>>>>>>>>>>>>>>>>>>>> /first/, including
>>>>>>>>>>>>>>>>>>>>> any "operating system" requirements that it has
>>>>>>>>>>>>>>>>>>>>> [which must then be
>>>>>>>>>>>>>>>>>>>>> included in "H_hat"].
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H only needs to be able to simulate its input
>>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time,
>>>>>>>>>>>>>>>>>>>> keep a set of execution traces of this simulation,
>>>>>>>>>>>>>>>>>>>> examine each trace
>>>>>>>>>>>>>>>>>>>> after each instruction is simulated
>>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time, and
>>>>>>>>>>>>>>>>>>>> detect when H^ calls H from the same machine address
>>>>>>>>>>>>>>>>>>>> twice with no
>>>>>>>>>>>>>>>>>>>> conditional branch instructions inbetween.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> To say that this is uncomputable is ridiculous.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We are saying it doesn't match the defintion of a
>>>>>>>>>>>>>>>>>>> Pure Computaiton.
>>>>>>>>>>>>>>>>>>> Primarily because due to your 'global' system, it
>>>>>>>>>>>>>>>>>>> gets information
>>>>>>>>>>>>>>>>>>> beyond its formal inputs. Build your system with just
>>>>>>>>>>>>>>>>>>> the local decider
>>>>>>>>>>>>>>>>>>> and you can get around that issue.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That may be the best approach, yet people are confused
>>>>>>>>>>>>>>>>>> by that one too.
>>>>>>>>>>>>>>>>>> To get around their confusion:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We can simply forget all about H^ and simply have
>>>>>>>>>>>>>>>>>> Halts decide halting on itself as a valid proxy for
>>>>>>>>>>>>>>>>>> Halts deciding halting on H^.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Because Halts decides that itself would be infinitely
>>>>>>>>>>>>>>>>>> recursive unless it aborted itself it is obvious that
>>>>>>>>>>>>>>>>>> appending some infinite loop states at the its end
>>>>>>>>>>>>>>>>>> won't change this correct halting decision.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If the only information that Halts
>>>>>>>>>>>>>>>>>>> uses is what happens after the call to it, then you
>>>>>>>>>>>>>>>>>>> are good there. You
>>>>>>>>>>>>>>>>>>> also need to remove the Halt Decider around main,
>>>>>>>>>>>>>>>>>>> that doesn't exist in
>>>>>>>>>>>>>>>>>>> the proofs you are looking at, and make your system
>>>>>>>>>>>>>>>>>>> no longer Turing
>>>>>>>>>>>>>>>>>>> Complete.
>>>>>>>>>>>>>>>>>> I don't need that when I drop H^ and use the Halts
>>>>>>>>>>>>>>>>>> proxy mentioned above.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I still must have a static local or a global that does
>>>>>>>>>>>>>>>>>> not immediately forget about all of the preceding
>>>>>>>>>>>>>>>>>> execution traces.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But, as has been pointed out, as soon as you start
>>>>>>>>>>>>>>>>> making use of persistent variables within your embedded
>>>>>>>>>>>>>>>>> call to H(^) you are no longer dealing with a
>>>>>>>>>>>>>>>>> computation. If your embedded H(^) isn't a computation,
>>>>>>>>>>>>>>>>> it has no corresponding Turing Machine, which means you
>>>>>>>>>>>>>>>>> aren't addressing the actual proofs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That does not effect the correctness of my halt decider
>>>>>>>>>>>>>>>> which is a pure function of finite strings to final states.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It *isn't* a pure function. That's the whole point.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Possibly, but the halting problem takes a description of a
>>>>>>>>>>>>> Turing Machine as its input, and the function which you are
>>>>>>>>>>>>> passing as an input is *not* a pure function. For whatever
>>>>>>>>>>>>> it is that you're doing to have any relevance whatsoever to
>>>>>>>>>>>>> the actual Halting Problem, you need the function which you
>>>>>>>>>>>>> pass as an input to your 'global decider' to be a pure
>>>>>>>>>>>>> function.
>>>>>>>>>>>>>
>>>>>>>>>>>>> André
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The global halt decider is a pure function of finite strings
>>>>>>>>>>>> to final states. If for whatever reason an undecidable input
>>>>>>>>>>>> cannot possibly be properly defined then the conventional
>>>>>>>>>>>> proofs have been refuted.
>>>>>>>>>>>
>>>>>>>>>>> There are no 'undecidable inputs' to the halting problem,
>>>>>>>>>>> only inputs that might be undecidable by a particular
>>>>>>>>>>> machine. No one has claimed that the input which fails on
>>>>>>>>>>> your machine cannot be properly defined (i.e. defined as pure
>>>>>>>>>>> computation), only that *you* have failed to do so.
>>>>>>>>>>>
>>>>>>>>>>> Right now your H_Hat is not a pure computation. If your
>>>>>>>>>>> global decider is indeed a pure computation, then you can
>>>>>>>>>>> easily define an H_Hat which *is* a pure computation --
>>>>>>>>>>> simply use the method outlined in Linz. You, however, refuse
>>>>>>>>>>> to do this.
>>>>>>>>>>>
>>>>>>>>>>> If you do actually do this, you will discover that your
>>>>>>>>>>> global decider will fail to correctly decide H_Hat.
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> An x86 function can detect when it is being called in infinite
>>>>>>>>>> recursion if a Turing machine cannot do this same thing then
>>>>>>>>>> we must conclude that x86 functions are strictly more powerful
>>>>>>>>>> than Turing machines and Church-Turing has been refuted.
>>>>>>>>>
>>>>>>>>> It can detect relatively trivial instances of infinite
>>>>>>>>> recursion. But what does this have to do with the observation
>>>>>>>>> that your input to Halts() is not a pure function?
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> An x86 function that can detect that it was called in infinite
>>>>>>>> recursion cannot possibly do this if it is required to forget
>>>>>>>> everything about all of its prior invocations.
>>>>>>>
>>>>>>> And a Turing machine *always* forgets everything about all its
>>>>>>> prior invocations. So you are basically admitting that your
>>>>>>> alleged solution won't work for actual Turing Machines.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> If I am "admitting" this then I am also "admitting" that x86
>>>>>> functions have proven to be strictly more powerful than Turing
>>>>>> machines because they can do something that Turing machine cannot do.
>>>>>
>>>>> An x86 program forgets everything about its prior invocations just
>>>>> as much as a Turing Machine does.
>>>>
>>>> My halting function requires static local memory, if Turing machines
>>>> cannot simulate static local memory then the C language is strictly
>>>> more powerful that a Turing machine because a C function with static
>>>> local memory can keep track of its every invocation.
>>>
>>> You're really not event trying to get this, are you? A function using
>>> static variables is *not* a computation because the value of that
>>> variable provides additional input to the computation which is not
>>> explicitly declared. That doesn't say anything about C being more
>>> powerful than Turing Machines. The following is not a computation due
>>> to the static variable.
>>
>> The TM has to do this:
>
> And if it does that, it can't be realized as a TM, so quit calling it
> one.
It either can be realized as a TM or the C function can do something
that a TM cannot do making it strictly more powerful than a TM.
> You need to pass execution_trace as an explicit variable if you
We can't do that because it creates this execution trace there is
nothing that can pass this execution trace to it.
> want to do that in a TM, but then you are no longer talking about the H
> of Linz since that TM takes only two arguments, not three.
As long as an undecidable input cannot be defined for this decider then
the halting problem proofs fail.
The static local data is merely global data. A TM can write this data to
its tape as a part of its own internal state as it simulates the input
string before writing the Boolean value. All of these additional
function calls are part of its own simulation of its input thus not
actual function calls.
> André
>
>> u32 Halts(u32 P, u32 I)
>> {
>> static u32* execution_trace;
>> slave_state->EIP = P; // Function to invoke
>> while (!Aborted)
>> {
>> u32 EIP = slave_state->EIP; // Instruction to be executed
>> DebugStep(master_state, slave_state); // Execute this instruction
>> PushBack(local_execution_trace_list, EIP);
>> Aborted = Needs_To_Be_Aborted(execution_trace, (u32)Halts);
>> }
>> return 0; // Does not halt
>> END_OF_CODE: // Input has normally terminated
>> return 1;
>> }
--
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-29 22:57 -0600 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) |
| Message-ID | <s3ub3j$4rt$1@dont-email.me> |
| In reply to | #30332 |
On 2021-03-29 22:24, olcott wrote:
> On 3/29/2021 11:11 PM, André G. Isaak wrote:
>> On 2021-03-29 21:38, olcott wrote:
>>> On 3/29/2021 10:25 PM, André G. Isaak wrote:
>>>> On 2021-03-29 20:12, olcott wrote:
>>>>> On 3/29/2021 9:06 PM, André G. Isaak wrote:
>>>>>> On 2021-03-29 19:48, olcott wrote:
>>>>>>> On 3/29/2021 8:25 PM, André G. Isaak wrote:
>>>>>>>> On 2021-03-29 19:22, olcott wrote:
>>>>>>>>> On 3/29/2021 7:41 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-03-29 16:42, olcott wrote:
>>>>>>>>>>> On 3/29/2021 4:36 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-03-29 14:57, olcott wrote:
>>>>>>>>>>>>> On 3/29/2021 3:10 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-03-29 14:00, olcott wrote:
>>>>>>>>>>>>>>> On 3/29/2021 12:43 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>> On 2021-03-29 10:53, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/29/2021 11:45 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>> On 2021-03-28 19:26, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/28/2021 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/28/21 8:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/28/2021 6:34 PM, Andy Walker wrote:
>>>>>>>>>>>>>>>>>>>>>> On 28/03/2021 23:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> [I wrote:]
>>>>>>>>>>>>>>>>>>>>>>>> [...] Let us know when you have an "H" and its
>>>>>>>>>>>>>>>>>>>>>>>> corresponding
>>>>>>>>>>>>>>>>>>>>>>>> /correct/ "H_hat", without all the flannel about
>>>>>>>>>>>>>>>>>>>>>>>> UTMs, inner and outer
>>>>>>>>>>>>>>>>>>>>>>>> invocations, recursion and so on, and can tell
>>>>>>>>>>>>>>>>>>>>>>>> us what they do.
>>>>>>>>>>>>>>>>>>>>>>> To define an H that correctly decides H^
>>>>>>>>>>>>>>>>>>>>>>> inherently requires that H
>>>>>>>>>>>>>>>>>>>>>>> be defined on the basis of a UTM that detects
>>>>>>>>>>>>>>>>>>>>>>> that itself has been
>>>>>>>>>>>>>>>>>>>>>>> invoked in infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> There is no such requirement, inherent or
>>>>>>>>>>>>>>>>>>>>>> otherwise; that is
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except for the fact that every other alternative
>>>>>>>>>>>>>>>>>>>>> can't possibly work...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Who says it has to work? Your arguement has the
>>>>>>>>>>>>>>>>>>>> falicy of assuming the
>>>>>>>>>>>>>>>>>>>> conclusion.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> entirely down to how you choose to write "H".
>>>>>>>>>>>>>>>>>>>>>> However, once you have
>>>>>>>>>>>>>>>>>>>>>> written "H", then by the definition of "H_hat" it
>>>>>>>>>>>>>>>>>>>>>> incorrectly decides
>>>>>>>>>>>>>>>>>>>>>> the nature of "H_hat". But you need to write "H"
>>>>>>>>>>>>>>>>>>>>>> /first/, including
>>>>>>>>>>>>>>>>>>>>>> any "operating system" requirements that it has
>>>>>>>>>>>>>>>>>>>>>> [which must then be
>>>>>>>>>>>>>>>>>>>>>> included in "H_hat"].
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H only needs to be able to simulate its input
>>>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time,
>>>>>>>>>>>>>>>>>>>>> keep a set of execution traces of this simulation,
>>>>>>>>>>>>>>>>>>>>> examine each trace
>>>>>>>>>>>>>>>>>>>>> after each instruction is simulated
>>>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time, and
>>>>>>>>>>>>>>>>>>>>> detect when H^ calls H from the same machine
>>>>>>>>>>>>>>>>>>>>> address twice with no
>>>>>>>>>>>>>>>>>>>>> conditional branch instructions inbetween.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> To say that this is uncomputable is ridiculous.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> We are saying it doesn't match the defintion of a
>>>>>>>>>>>>>>>>>>>> Pure Computaiton.
>>>>>>>>>>>>>>>>>>>> Primarily because due to your 'global' system, it
>>>>>>>>>>>>>>>>>>>> gets information
>>>>>>>>>>>>>>>>>>>> beyond its formal inputs. Build your system with
>>>>>>>>>>>>>>>>>>>> just the local decider
>>>>>>>>>>>>>>>>>>>> and you can get around that issue.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That may be the best approach, yet people are
>>>>>>>>>>>>>>>>>>> confused by that one too.
>>>>>>>>>>>>>>>>>>> To get around their confusion:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We can simply forget all about H^ and simply have
>>>>>>>>>>>>>>>>>>> Halts decide halting on itself as a valid proxy for
>>>>>>>>>>>>>>>>>>> Halts deciding halting on H^.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Because Halts decides that itself would be infinitely
>>>>>>>>>>>>>>>>>>> recursive unless it aborted itself it is obvious that
>>>>>>>>>>>>>>>>>>> appending some infinite loop states at the its end
>>>>>>>>>>>>>>>>>>> won't change this correct halting decision.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If the only information that Halts
>>>>>>>>>>>>>>>>>>>> uses is what happens after the call to it, then you
>>>>>>>>>>>>>>>>>>>> are good there. You
>>>>>>>>>>>>>>>>>>>> also need to remove the Halt Decider around main,
>>>>>>>>>>>>>>>>>>>> that doesn't exist in
>>>>>>>>>>>>>>>>>>>> the proofs you are looking at, and make your system
>>>>>>>>>>>>>>>>>>>> no longer Turing
>>>>>>>>>>>>>>>>>>>> Complete.
>>>>>>>>>>>>>>>>>>> I don't need that when I drop H^ and use the Halts
>>>>>>>>>>>>>>>>>>> proxy mentioned above.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I still must have a static local or a global that
>>>>>>>>>>>>>>>>>>> does not immediately forget about all of the
>>>>>>>>>>>>>>>>>>> preceding execution traces.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But, as has been pointed out, as soon as you start
>>>>>>>>>>>>>>>>>> making use of persistent variables within your
>>>>>>>>>>>>>>>>>> embedded call to H(^) you are no longer dealing with a
>>>>>>>>>>>>>>>>>> computation. If your embedded H(^) isn't a
>>>>>>>>>>>>>>>>>> computation, it has no corresponding Turing Machine,
>>>>>>>>>>>>>>>>>> which means you aren't addressing the actual proofs.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That does not effect the correctness of my halt decider
>>>>>>>>>>>>>>>>> which is a pure function of finite strings to final
>>>>>>>>>>>>>>>>> states.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It *isn't* a pure function. That's the whole point.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Possibly, but the halting problem takes a description of a
>>>>>>>>>>>>>> Turing Machine as its input, and the function which you
>>>>>>>>>>>>>> are passing as an input is *not* a pure function. For
>>>>>>>>>>>>>> whatever it is that you're doing to have any relevance
>>>>>>>>>>>>>> whatsoever to the actual Halting Problem, you need the
>>>>>>>>>>>>>> function which you pass as an input to your 'global
>>>>>>>>>>>>>> decider' to be a pure function.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The global halt decider is a pure function of finite
>>>>>>>>>>>>> strings to final states. If for whatever reason an
>>>>>>>>>>>>> undecidable input cannot possibly be properly defined then
>>>>>>>>>>>>> the conventional proofs have been refuted.
>>>>>>>>>>>>
>>>>>>>>>>>> There are no 'undecidable inputs' to the halting problem,
>>>>>>>>>>>> only inputs that might be undecidable by a particular
>>>>>>>>>>>> machine. No one has claimed that the input which fails on
>>>>>>>>>>>> your machine cannot be properly defined (i.e. defined as
>>>>>>>>>>>> pure computation), only that *you* have failed to do so.
>>>>>>>>>>>>
>>>>>>>>>>>> Right now your H_Hat is not a pure computation. If your
>>>>>>>>>>>> global decider is indeed a pure computation, then you can
>>>>>>>>>>>> easily define an H_Hat which *is* a pure computation --
>>>>>>>>>>>> simply use the method outlined in Linz. You, however, refuse
>>>>>>>>>>>> to do this.
>>>>>>>>>>>>
>>>>>>>>>>>> If you do actually do this, you will discover that your
>>>>>>>>>>>> global decider will fail to correctly decide H_Hat.
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> An x86 function can detect when it is being called in
>>>>>>>>>>> infinite recursion if a Turing machine cannot do this same
>>>>>>>>>>> thing then we must conclude that x86 functions are strictly
>>>>>>>>>>> more powerful than Turing machines and Church-Turing has been
>>>>>>>>>>> refuted.
>>>>>>>>>>
>>>>>>>>>> It can detect relatively trivial instances of infinite
>>>>>>>>>> recursion. But what does this have to do with the observation
>>>>>>>>>> that your input to Halts() is not a pure function?
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> An x86 function that can detect that it was called in infinite
>>>>>>>>> recursion cannot possibly do this if it is required to forget
>>>>>>>>> everything about all of its prior invocations.
>>>>>>>>
>>>>>>>> And a Turing machine *always* forgets everything about all its
>>>>>>>> prior invocations. So you are basically admitting that your
>>>>>>>> alleged solution won't work for actual Turing Machines.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> If I am "admitting" this then I am also "admitting" that x86
>>>>>>> functions have proven to be strictly more powerful than Turing
>>>>>>> machines because they can do something that Turing machine cannot
>>>>>>> do.
>>>>>>
>>>>>> An x86 program forgets everything about its prior invocations just
>>>>>> as much as a Turing Machine does.
>>>>>
>>>>> My halting function requires static local memory, if Turing
>>>>> machines cannot simulate static local memory then the C language is
>>>>> strictly more powerful that a Turing machine because a C function
>>>>> with static local memory can keep track of its every invocation.
>>>>
>>>> You're really not event trying to get this, are you? A function
>>>> using static variables is *not* a computation because the value of
>>>> that variable provides additional input to the computation which is
>>>> not explicitly declared. That doesn't say anything about C being
>>>> more powerful than Turing Machines. The following is not a
>>>> computation due to the static variable.
>>>
>>> The TM has to do this:
>>
>> And if it does that, it can't be realized as a TM, so quit calling it
>> one.
>
> It either can be realized as a TM or the C function can do something
> that a TM cannot do making it strictly more powerful than a TM.
No. It simply means that C allows certain details to be hidden from the
programmer.
A static 'local' variable is really a local variable at all. It is just
a global variable that the compiler doesn't allow other functions to
see. So it isn't actually part of the function it is declared in.
Perhaps it would help if you thought of Turing Machines as complete
programs rather than as isolated C functions. What a halt decider is
expected to take as an input is some complete program which can be
compiled and linked into an executable that will run independently. That
means it must include all code that it needs to run. It can't be some
function which calls other functions unless those functions are included
in the final executable.
>> You need to pass execution_trace as an explicit variable if you
>
> We can't do that because it creates this execution trace there is
> nothing that can pass this execution trace to it.
>
>> want to do that in a TM, but then you are no longer talking about the
>> H of Linz since that TM takes only two arguments, not three.
>
> As long as an undecidable input cannot be defined for this decider then
> the halting problem proofs fail.
No, those proofs don't fail. The fact that you can't define what you are
trying to define in a way that makes it a pure computation simply
indicates that your approach fails. The proofs stills stand, just as
they always have.
> The static local data is merely global data. A TM can write this data to
> its tape as a part of its own internal state as it simulates the input
But the program it is simulating can't see any of that. That includes
the call to Halts from within H_Hat. It knows nothing about the outer
Halts() in which it is running. It can only access data on the tape
which was part of its input or which it write to the tape itself.
André
> string before writing the Boolean value. All of these additional
> function calls are part of its own simulation of its input thus not
> actual function calls.
>
>> André
>>
>>> u32 Halts(u32 P, u32 I)
>>> {
>>> static u32* execution_trace;
>>> slave_state->EIP = P; // Function to invoke
>>> while (!Aborted)
>>> {
>>> u32 EIP = slave_state->EIP; // Instruction to be
>>> executed
>>> DebugStep(master_state, slave_state); // Execute this instruction
>>> PushBack(local_execution_trace_list, EIP);
>>> Aborted = Needs_To_Be_Aborted(execution_trace, (u32)Halts);
>>> }
>>> return 0; // Does not halt
>>> END_OF_CODE: // Input has normally terminated
>>> return 1;
>>> }
>
>
>
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-30 08:09 -0400 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) |
| Message-ID | <lyE8I.94043$I21.16229@fx21.iad> |
| In reply to | #30332 |
On 3/30/21 12:24 AM, olcott wrote:
> On 3/29/2021 11:11 PM, André G. Isaak wrote:
>> On 2021-03-29 21:38, olcott wrote:
>>> On 3/29/2021 10:25 PM, André G. Isaak wrote:
>>>> On 2021-03-29 20:12, olcott wrote:
>>>>> On 3/29/2021 9:06 PM, André G. Isaak wrote:
>>>>>> On 2021-03-29 19:48, olcott wrote:
>>>>>>> On 3/29/2021 8:25 PM, André G. Isaak wrote:
>>>>>>>> On 2021-03-29 19:22, olcott wrote:
>>>>>>>>> On 3/29/2021 7:41 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-03-29 16:42, olcott wrote:
>>>>>>>>>>> On 3/29/2021 4:36 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-03-29 14:57, olcott wrote:
>>>>>>>>>>>>> On 3/29/2021 3:10 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-03-29 14:00, olcott wrote:
>>>>>>>>>>>>>>> On 3/29/2021 12:43 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>> On 2021-03-29 10:53, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/29/2021 11:45 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>> On 2021-03-28 19:26, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/28/2021 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/28/21 8:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/28/2021 6:34 PM, Andy Walker wrote:
>>>>>>>>>>>>>>>>>>>>>> On 28/03/2021 23:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> [I wrote:]
>>>>>>>>>>>>>>>>>>>>>>>> [...] Let us know when you have an "H" and its
>>>>>>>>>>>>>>>>>>>>>>>> corresponding
>>>>>>>>>>>>>>>>>>>>>>>> /correct/ "H_hat", without all the flannel about
>>>>>>>>>>>>>>>>>>>>>>>> UTMs, inner and outer
>>>>>>>>>>>>>>>>>>>>>>>> invocations, recursion and so on, and can tell
>>>>>>>>>>>>>>>>>>>>>>>> us what they do.
>>>>>>>>>>>>>>>>>>>>>>> To define an H that correctly decides H^
>>>>>>>>>>>>>>>>>>>>>>> inherently requires that H
>>>>>>>>>>>>>>>>>>>>>>> be defined on the basis of a UTM that detects
>>>>>>>>>>>>>>>>>>>>>>> that itself has been
>>>>>>>>>>>>>>>>>>>>>>> invoked in infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> There is no such requirement, inherent or
>>>>>>>>>>>>>>>>>>>>>> otherwise; that is
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except for the fact that every other alternative
>>>>>>>>>>>>>>>>>>>>> can't possibly work...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Who says it has to work? Your arguement has the
>>>>>>>>>>>>>>>>>>>> falicy of assuming the
>>>>>>>>>>>>>>>>>>>> conclusion.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> entirely down to how you choose to write "H".
>>>>>>>>>>>>>>>>>>>>>> However, once you have
>>>>>>>>>>>>>>>>>>>>>> written "H", then by the definition of "H_hat" it
>>>>>>>>>>>>>>>>>>>>>> incorrectly decides
>>>>>>>>>>>>>>>>>>>>>> the nature of "H_hat". But you need to write "H"
>>>>>>>>>>>>>>>>>>>>>> /first/, including
>>>>>>>>>>>>>>>>>>>>>> any "operating system" requirements that it has
>>>>>>>>>>>>>>>>>>>>>> [which must then be
>>>>>>>>>>>>>>>>>>>>>> included in "H_hat"].
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H only needs to be able to simulate its input
>>>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time,
>>>>>>>>>>>>>>>>>>>>> keep a set of execution traces of this simulation,
>>>>>>>>>>>>>>>>>>>>> examine each trace
>>>>>>>>>>>>>>>>>>>>> after each instruction is simulated
>>>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time, and
>>>>>>>>>>>>>>>>>>>>> detect when H^ calls H from the same machine
>>>>>>>>>>>>>>>>>>>>> address twice with no
>>>>>>>>>>>>>>>>>>>>> conditional branch instructions inbetween.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> To say that this is uncomputable is ridiculous.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> We are saying it doesn't match the defintion of a
>>>>>>>>>>>>>>>>>>>> Pure Computaiton.
>>>>>>>>>>>>>>>>>>>> Primarily because due to your 'global' system, it
>>>>>>>>>>>>>>>>>>>> gets information
>>>>>>>>>>>>>>>>>>>> beyond its formal inputs. Build your system with
>>>>>>>>>>>>>>>>>>>> just the local decider
>>>>>>>>>>>>>>>>>>>> and you can get around that issue.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That may be the best approach, yet people are
>>>>>>>>>>>>>>>>>>> confused by that one too.
>>>>>>>>>>>>>>>>>>> To get around their confusion:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We can simply forget all about H^ and simply have
>>>>>>>>>>>>>>>>>>> Halts decide halting on itself as a valid proxy for
>>>>>>>>>>>>>>>>>>> Halts deciding halting on H^.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Because Halts decides that itself would be infinitely
>>>>>>>>>>>>>>>>>>> recursive unless it aborted itself it is obvious that
>>>>>>>>>>>>>>>>>>> appending some infinite loop states at the its end
>>>>>>>>>>>>>>>>>>> won't change this correct halting decision.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If the only information that Halts
>>>>>>>>>>>>>>>>>>>> uses is what happens after the call to it, then you
>>>>>>>>>>>>>>>>>>>> are good there. You
>>>>>>>>>>>>>>>>>>>> also need to remove the Halt Decider around main,
>>>>>>>>>>>>>>>>>>>> that doesn't exist in
>>>>>>>>>>>>>>>>>>>> the proofs you are looking at, and make your system
>>>>>>>>>>>>>>>>>>>> no longer Turing
>>>>>>>>>>>>>>>>>>>> Complete.
>>>>>>>>>>>>>>>>>>> I don't need that when I drop H^ and use the Halts
>>>>>>>>>>>>>>>>>>> proxy mentioned above.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I still must have a static local or a global that
>>>>>>>>>>>>>>>>>>> does not immediately forget about all of the
>>>>>>>>>>>>>>>>>>> preceding execution traces.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But, as has been pointed out, as soon as you start
>>>>>>>>>>>>>>>>>> making use of persistent variables within your
>>>>>>>>>>>>>>>>>> embedded call to H(^) you are no longer dealing with a
>>>>>>>>>>>>>>>>>> computation. If your embedded H(^) isn't a
>>>>>>>>>>>>>>>>>> computation, it has no corresponding Turing Machine,
>>>>>>>>>>>>>>>>>> which means you aren't addressing the actual proofs.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That does not effect the correctness of my halt decider
>>>>>>>>>>>>>>>>> which is a pure function of finite strings to final
>>>>>>>>>>>>>>>>> states.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It *isn't* a pure function. That's the whole point.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Possibly, but the halting problem takes a description of a
>>>>>>>>>>>>>> Turing Machine as its input, and the function which you
>>>>>>>>>>>>>> are passing as an input is *not* a pure function. For
>>>>>>>>>>>>>> whatever it is that you're doing to have any relevance
>>>>>>>>>>>>>> whatsoever to the actual Halting Problem, you need the
>>>>>>>>>>>>>> function which you pass as an input to your 'global
>>>>>>>>>>>>>> decider' to be a pure function.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The global halt decider is a pure function of finite
>>>>>>>>>>>>> strings to final states. If for whatever reason an
>>>>>>>>>>>>> undecidable input cannot possibly be properly defined then
>>>>>>>>>>>>> the conventional proofs have been refuted.
>>>>>>>>>>>>
>>>>>>>>>>>> There are no 'undecidable inputs' to the halting problem,
>>>>>>>>>>>> only inputs that might be undecidable by a particular
>>>>>>>>>>>> machine. No one has claimed that the input which fails on
>>>>>>>>>>>> your machine cannot be properly defined (i.e. defined as
>>>>>>>>>>>> pure computation), only that *you* have failed to do so.
>>>>>>>>>>>>
>>>>>>>>>>>> Right now your H_Hat is not a pure computation. If your
>>>>>>>>>>>> global decider is indeed a pure computation, then you can
>>>>>>>>>>>> easily define an H_Hat which *is* a pure computation --
>>>>>>>>>>>> simply use the method outlined in Linz. You, however, refuse
>>>>>>>>>>>> to do this.
>>>>>>>>>>>>
>>>>>>>>>>>> If you do actually do this, you will discover that your
>>>>>>>>>>>> global decider will fail to correctly decide H_Hat.
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> An x86 function can detect when it is being called in
>>>>>>>>>>> infinite recursion if a Turing machine cannot do this same
>>>>>>>>>>> thing then we must conclude that x86 functions are strictly
>>>>>>>>>>> more powerful than Turing machines and Church-Turing has been
>>>>>>>>>>> refuted.
>>>>>>>>>>
>>>>>>>>>> It can detect relatively trivial instances of infinite
>>>>>>>>>> recursion. But what does this have to do with the observation
>>>>>>>>>> that your input to Halts() is not a pure function?
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> An x86 function that can detect that it was called in infinite
>>>>>>>>> recursion cannot possibly do this if it is required to forget
>>>>>>>>> everything about all of its prior invocations.
>>>>>>>>
>>>>>>>> And a Turing machine *always* forgets everything about all its
>>>>>>>> prior invocations. So you are basically admitting that your
>>>>>>>> alleged solution won't work for actual Turing Machines.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> If I am "admitting" this then I am also "admitting" that x86
>>>>>>> functions have proven to be strictly more powerful than Turing
>>>>>>> machines because they can do something that Turing machine cannot
>>>>>>> do.
>>>>>>
>>>>>> An x86 program forgets everything about its prior invocations just
>>>>>> as much as a Turing Machine does.
>>>>>
>>>>> My halting function requires static local memory, if Turing
>>>>> machines cannot simulate static local memory then the C language is
>>>>> strictly more powerful that a Turing machine because a C function
>>>>> with static local memory can keep track of its every invocation.
>>>>
>>>> You're really not event trying to get this, are you? A function
>>>> using static variables is *not* a computation because the value of
>>>> that variable provides additional input to the computation which is
>>>> not explicitly declared. That doesn't say anything about C being
>>>> more powerful than Turing Machines. The following is not a
>>>> computation due to the static variable.
>>>
>>> The TM has to do this:
>>
>> And if it does that, it can't be realized as a TM, so quit calling it
>> one.
>
> It either can be realized as a TM or the C function can do something
> that a TM cannot do making it strictly more powerful than a TM.>
>> You need to pass execution_trace as an explicit variable if you
>
> We can't do that because it creates this execution trace there is
> nothing that can pass this execution trace to it.
>
>> want to do that in a TM, but then you are no longer talking about the
>> H of Linz since that TM takes only two arguments, not three.
>
> As long as an undecidable input cannot be defined for this decider then
> the halting problem proofs fail.
>
> The static local data is merely global data. A TM can write this data to
> its tape as a part of its own internal state as it simulates the input
> string before writing the Boolean value. All of these additional
> function calls are part of its own simulation of its input thus not
> actual function calls.
>
>> André
>>
>>> u32 Halts(u32 P, u32 I)
>>> {
>>> static u32* execution_trace;
>>> slave_state->EIP = P; // Function to invoke
>>> while (!Aborted)
>>> {
>>> u32 EIP = slave_state->EIP; // Instruction to be
>>> executed
>>> DebugStep(master_state, slave_state); // Execute this instruction
>>> PushBack(local_execution_trace_list, EIP);
>>> Aborted = Needs_To_Be_Aborted(execution_trace, (u32)Halts);
>>> }
>>> return 0; // Does not halt
>>> END_OF_CODE: // Input has normally terminated
>>> return 1;
>>> }
>
>
>
If I try to rhun that code, as it stands, I will get a set of linker
errors, because it uses functionality that is not included.
THAT is the piece that you can't do in Turing Machines, because you
really can't do that in C either. You need ALL the code.
When you include all the code, you now get a complete computation that
is the Turing Machine equivalent, and then you can perform that H^
transformation to that FULL Program.
Note, this means H_Hat is a stand alone program, not a piece of code
that runs under the x86utm 'os'.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-30 09:43 -0500 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) |
| Message-ID | <6uidnZYUmrZmpf79nZ2dnUU7-QnNnZ2d@giganews.com> |
| In reply to | #30337 |
On 3/30/2021 7:09 AM, Richard Damon wrote:
> On 3/30/21 12:24 AM, olcott wrote:
>> On 3/29/2021 11:11 PM, André G. Isaak wrote:
>>> On 2021-03-29 21:38, olcott wrote:
>>>> On 3/29/2021 10:25 PM, André G. Isaak wrote:
>>>>> On 2021-03-29 20:12, olcott wrote:
>>>>>> On 3/29/2021 9:06 PM, André G. Isaak wrote:
>>>>>>> On 2021-03-29 19:48, olcott wrote:
>>>>>>>> On 3/29/2021 8:25 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-03-29 19:22, olcott wrote:
>>>>>>>>>> On 3/29/2021 7:41 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-03-29 16:42, olcott wrote:
>>>>>>>>>>>> On 3/29/2021 4:36 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-03-29 14:57, olcott wrote:
>>>>>>>>>>>>>> On 3/29/2021 3:10 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2021-03-29 14:00, olcott wrote:
>>>>>>>>>>>>>>>> On 3/29/2021 12:43 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>> On 2021-03-29 10:53, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/29/2021 11:45 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>> On 2021-03-28 19:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/28/2021 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/28/21 8:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/28/2021 6:34 PM, Andy Walker wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 28/03/2021 23:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> [I wrote:]
>>>>>>>>>>>>>>>>>>>>>>>>> [...] Let us know when you have an "H" and its
>>>>>>>>>>>>>>>>>>>>>>>>> corresponding
>>>>>>>>>>>>>>>>>>>>>>>>> /correct/ "H_hat", without all the flannel about
>>>>>>>>>>>>>>>>>>>>>>>>> UTMs, inner and outer
>>>>>>>>>>>>>>>>>>>>>>>>> invocations, recursion and so on, and can tell
>>>>>>>>>>>>>>>>>>>>>>>>> us what they do.
>>>>>>>>>>>>>>>>>>>>>>>> To define an H that correctly decides H^
>>>>>>>>>>>>>>>>>>>>>>>> inherently requires that H
>>>>>>>>>>>>>>>>>>>>>>>> be defined on the basis of a UTM that detects
>>>>>>>>>>>>>>>>>>>>>>>> that itself has been
>>>>>>>>>>>>>>>>>>>>>>>> invoked in infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> There is no such requirement, inherent or
>>>>>>>>>>>>>>>>>>>>>>> otherwise; that is
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except for the fact that every other alternative
>>>>>>>>>>>>>>>>>>>>>> can't possibly work...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Who says it has to work? Your arguement has the
>>>>>>>>>>>>>>>>>>>>> falicy of assuming the
>>>>>>>>>>>>>>>>>>>>> conclusion.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> entirely down to how you choose to write "H".
>>>>>>>>>>>>>>>>>>>>>>> However, once you have
>>>>>>>>>>>>>>>>>>>>>>> written "H", then by the definition of "H_hat" it
>>>>>>>>>>>>>>>>>>>>>>> incorrectly decides
>>>>>>>>>>>>>>>>>>>>>>> the nature of "H_hat". But you need to write "H"
>>>>>>>>>>>>>>>>>>>>>>> /first/, including
>>>>>>>>>>>>>>>>>>>>>>> any "operating system" requirements that it has
>>>>>>>>>>>>>>>>>>>>>>> [which must then be
>>>>>>>>>>>>>>>>>>>>>>> included in "H_hat"].
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H only needs to be able to simulate its input
>>>>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time,
>>>>>>>>>>>>>>>>>>>>>> keep a set of execution traces of this simulation,
>>>>>>>>>>>>>>>>>>>>>> examine each trace
>>>>>>>>>>>>>>>>>>>>>> after each instruction is simulated
>>>>>>>>>>>>>>>>>>>>>> one-instruction-at-a-time, and
>>>>>>>>>>>>>>>>>>>>>> detect when H^ calls H from the same machine
>>>>>>>>>>>>>>>>>>>>>> address twice with no
>>>>>>>>>>>>>>>>>>>>>> conditional branch instructions inbetween.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> To say that this is uncomputable is ridiculous.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> We are saying it doesn't match the defintion of a
>>>>>>>>>>>>>>>>>>>>> Pure Computaiton.
>>>>>>>>>>>>>>>>>>>>> Primarily because due to your 'global' system, it
>>>>>>>>>>>>>>>>>>>>> gets information
>>>>>>>>>>>>>>>>>>>>> beyond its formal inputs. Build your system with
>>>>>>>>>>>>>>>>>>>>> just the local decider
>>>>>>>>>>>>>>>>>>>>> and you can get around that issue.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That may be the best approach, yet people are
>>>>>>>>>>>>>>>>>>>> confused by that one too.
>>>>>>>>>>>>>>>>>>>> To get around their confusion:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> We can simply forget all about H^ and simply have
>>>>>>>>>>>>>>>>>>>> Halts decide halting on itself as a valid proxy for
>>>>>>>>>>>>>>>>>>>> Halts deciding halting on H^.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Because Halts decides that itself would be infinitely
>>>>>>>>>>>>>>>>>>>> recursive unless it aborted itself it is obvious that
>>>>>>>>>>>>>>>>>>>> appending some infinite loop states at the its end
>>>>>>>>>>>>>>>>>>>> won't change this correct halting decision.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If the only information that Halts
>>>>>>>>>>>>>>>>>>>>> uses is what happens after the call to it, then you
>>>>>>>>>>>>>>>>>>>>> are good there. You
>>>>>>>>>>>>>>>>>>>>> also need to remove the Halt Decider around main,
>>>>>>>>>>>>>>>>>>>>> that doesn't exist in
>>>>>>>>>>>>>>>>>>>>> the proofs you are looking at, and make your system
>>>>>>>>>>>>>>>>>>>>> no longer Turing
>>>>>>>>>>>>>>>>>>>>> Complete.
>>>>>>>>>>>>>>>>>>>> I don't need that when I drop H^ and use the Halts
>>>>>>>>>>>>>>>>>>>> proxy mentioned above.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I still must have a static local or a global that
>>>>>>>>>>>>>>>>>>>> does not immediately forget about all of the
>>>>>>>>>>>>>>>>>>>> preceding execution traces.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But, as has been pointed out, as soon as you start
>>>>>>>>>>>>>>>>>>> making use of persistent variables within your
>>>>>>>>>>>>>>>>>>> embedded call to H(^) you are no longer dealing with a
>>>>>>>>>>>>>>>>>>> computation. If your embedded H(^) isn't a
>>>>>>>>>>>>>>>>>>> computation, it has no corresponding Turing Machine,
>>>>>>>>>>>>>>>>>>> which means you aren't addressing the actual proofs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That does not effect the correctness of my halt decider
>>>>>>>>>>>>>>>>>> which is a pure function of finite strings to final
>>>>>>>>>>>>>>>>>> states.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It *isn't* a pure function. That's the whole point.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Possibly, but the halting problem takes a description of a
>>>>>>>>>>>>>>> Turing Machine as its input, and the function which you
>>>>>>>>>>>>>>> are passing as an input is *not* a pure function. For
>>>>>>>>>>>>>>> whatever it is that you're doing to have any relevance
>>>>>>>>>>>>>>> whatsoever to the actual Halting Problem, you need the
>>>>>>>>>>>>>>> function which you pass as an input to your 'global
>>>>>>>>>>>>>>> decider' to be a pure function.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The global halt decider is a pure function of finite
>>>>>>>>>>>>>> strings to final states. If for whatever reason an
>>>>>>>>>>>>>> undecidable input cannot possibly be properly defined then
>>>>>>>>>>>>>> the conventional proofs have been refuted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> There are no 'undecidable inputs' to the halting problem,
>>>>>>>>>>>>> only inputs that might be undecidable by a particular
>>>>>>>>>>>>> machine. No one has claimed that the input which fails on
>>>>>>>>>>>>> your machine cannot be properly defined (i.e. defined as
>>>>>>>>>>>>> pure computation), only that *you* have failed to do so.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right now your H_Hat is not a pure computation. If your
>>>>>>>>>>>>> global decider is indeed a pure computation, then you can
>>>>>>>>>>>>> easily define an H_Hat which *is* a pure computation --
>>>>>>>>>>>>> simply use the method outlined in Linz. You, however, refuse
>>>>>>>>>>>>> to do this.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you do actually do this, you will discover that your
>>>>>>>>>>>>> global decider will fail to correctly decide H_Hat.
>>>>>>>>>>>>>
>>>>>>>>>>>>> André
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> An x86 function can detect when it is being called in
>>>>>>>>>>>> infinite recursion if a Turing machine cannot do this same
>>>>>>>>>>>> thing then we must conclude that x86 functions are strictly
>>>>>>>>>>>> more powerful than Turing machines and Church-Turing has been
>>>>>>>>>>>> refuted.
>>>>>>>>>>>
>>>>>>>>>>> It can detect relatively trivial instances of infinite
>>>>>>>>>>> recursion. But what does this have to do with the observation
>>>>>>>>>>> that your input to Halts() is not a pure function?
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> An x86 function that can detect that it was called in infinite
>>>>>>>>>> recursion cannot possibly do this if it is required to forget
>>>>>>>>>> everything about all of its prior invocations.
>>>>>>>>>
>>>>>>>>> And a Turing machine *always* forgets everything about all its
>>>>>>>>> prior invocations. So you are basically admitting that your
>>>>>>>>> alleged solution won't work for actual Turing Machines.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> If I am "admitting" this then I am also "admitting" that x86
>>>>>>>> functions have proven to be strictly more powerful than Turing
>>>>>>>> machines because they can do something that Turing machine cannot
>>>>>>>> do.
>>>>>>>
>>>>>>> An x86 program forgets everything about its prior invocations just
>>>>>>> as much as a Turing Machine does.
>>>>>>
>>>>>> My halting function requires static local memory, if Turing
>>>>>> machines cannot simulate static local memory then the C language is
>>>>>> strictly more powerful that a Turing machine because a C function
>>>>>> with static local memory can keep track of its every invocation.
>>>>>
>>>>> You're really not event trying to get this, are you? A function
>>>>> using static variables is *not* a computation because the value of
>>>>> that variable provides additional input to the computation which is
>>>>> not explicitly declared. That doesn't say anything about C being
>>>>> more powerful than Turing Machines. The following is not a
>>>>> computation due to the static variable.
>>>>
>>>> The TM has to do this:
>>>
>>> And if it does that, it can't be realized as a TM, so quit calling it
>>> one.
>>
>> It either can be realized as a TM or the C function can do something
>> that a TM cannot do making it strictly more powerful than a TM.>
>>> You need to pass execution_trace as an explicit variable if you
>>
>> We can't do that because it creates this execution trace there is
>> nothing that can pass this execution trace to it.
>>
>>> want to do that in a TM, but then you are no longer talking about the
>>> H of Linz since that TM takes only two arguments, not three.
>>
>> As long as an undecidable input cannot be defined for this decider then
>> the halting problem proofs fail.
>>
>> The static local data is merely global data. A TM can write this data to
>> its tape as a part of its own internal state as it simulates the input
>> string before writing the Boolean value. All of these additional
>> function calls are part of its own simulation of its input thus not
>> actual function calls.
>>
>>> André
>>>
>>>> u32 Halts(u32 P, u32 I)
>>>> {
>>>> static u32* execution_trace;
>>>> slave_state->EIP = P; // Function to invoke
>>>> while (!Aborted)
>>>> {
>>>> u32 EIP = slave_state->EIP; // Instruction to be
>>>> executed
>>>> DebugStep(master_state, slave_state); // Execute this instruction
>>>> PushBack(local_execution_trace_list, EIP);
>>>> Aborted = Needs_To_Be_Aborted(execution_trace, (u32)Halts);
>>>> }
>>>> return 0; // Does not halt
>>>> END_OF_CODE: // Input has normally terminated
>>>> return 1;
>>>> }
>>
>>
>>
>
> If I try to rhun that code, as it stands, I will get a set of linker
> errors, because it uses functionality that is not included.
>
I had to strip out a lot of the infrastructure so that the gist of the
idea would be not hidden in a myriad of details.
> THAT is the piece that you can't do in Turing Machines, because you
> really can't do that in C either. You need ALL the code.
>
> When you include all the code, you now get a complete computation that
> is the Turing Machine equivalent, and then you can perform that H^
> transformation to that FULL Program.
>
> Note, this means H_Hat is a stand alone program, not a piece of code
> that runs under the x86utm 'os'.
>
So in other words the static variables are OK?
// This invokes a function based on 900 pages of source code
DebugStep(master_state, slave_state);
--
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-30 15:29 +0000 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) |
| Message-ID | <20210330082127.695@kylheku.com> |
| In reply to | #30347 |
On 2021-03-30, olcott <NoOne@NoWhere.com> wrote:
> On 3/30/2021 7:09 AM, Richard Damon wrote:
>> If I try to rhun that code, as it stands, I will get a set of linker
>> errors, because it uses functionality that is not included.
>>
>
> I had to strip out a lot of the infrastructure so that the gist of the
> idea would be not hidden in a myriad of details.
No, the person who did that was I.
The idiocy of your approach is completely embodied in my simple
one-source-file C program.
Direct call to Halts from main gets a 0:
$ ./halt
entering fun 40fab2 (main) at line 133
entering fun 40f8c0 (Halts) at line 98
Halts calling 40f848(40f848)
entering fun 40f848 (H_Hat) at line 85
entering fun 40f8c0 (Halts) at line 98
Halts calling 40f848(40f848)
entering fun 40f848 (H_Hat) at line 85
entering fun 40f8c0 (Halts) at line 98
Halts calling 40f848(40f848)
entering fun 40f848 (H_Hat) at line 85
entering fun 40f8c0 (Halts) at line 98
Halts calling 40f848(40f848)
entering fun 40f848 (H_Hat) at line 85
entering fun 40f8c0 (Halts) at line 98
runaway recursion detected!
exiting fun 40f8c0 (Halts) at line 118
Call to 40f848(40f848) aborted due to runaway recursion!
exiting fun 40f8c0 (Halts) at line 113
Input_Halts = 0
exiting fun 40fab2 (main) at line 153
Call to H_Hat from main aborts:
$ ./halt -h
entering fun 406ab2 (main) at line 133
calling H_Hat(H_Hat)
entering fun 406848 (H_Hat) at line 85
entering fun 4068c0 (Halts) at line 98
Halts calling 406848(406848)
entering fun 406848 (H_Hat) at line 85
entering fun 4068c0 (Halts) at line 98
Halts calling 406848(406848)
entering fun 406848 (H_Hat) at line 85
entering fun 4068c0 (Halts) at line 98
Halts calling 406848(406848)
entering fun 406848 (H_Hat) at line 85
entering fun 4068c0 (Halts) at line 98
runaway recursion detected!
exiting fun 4068c0 (Halts) at line 118
aborting
Aborted (core dumped)
Infinite loop is aborted:
$ ./halt -l
entering fun 464ab2 (main) at line 133
excuting statement at line 143
excuting statement at line 143
excuting statement at line 143
excuting statement at line 143
loop detected in line 143!
most recently entered function: 464ab2 (main) at line 133
aborting
Aborted (core dumped)
Full, self-contained source code:
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
#define array_size(array) (sizeof array / sizeof array[0])
#define TRACE_MAX 128
typedef uintptr_t word;
typedef enum { fun_entry, fun_exit, statement } trace_type;
typedef struct {
trace_type type;
word function;
int line;
const char *fname;
} trace_record;
trace_record exec_trace[TRACE_MAX];
unsigned trace_idx = 0;
jmp_buf abort_jmp;
static word Halts(word, word);
static void record_trace(trace_type type, word fun, int line, const char *fname)
{
if (trace_idx < array_size(exec_trace)) {
exec_trace[trace_idx].type = type;
exec_trace[trace_idx].function = fun;
exec_trace[trace_idx].line = line;
exec_trace[trace_idx++].fname = fname;
switch (type) {
case fun_entry:
case fun_exit:
printf("%s fun %lx (%s) at line %d\n",
type == fun_entry ? "entering" : "exiting",
(unsigned long) fun, fname, line);
break;
case statement:
printf("excuting statement at line %d\n", line);
break;
}
if (trace_idx >= 4 && type == statement &&
exec_trace[trace_idx - 1].line == line &&
exec_trace[trace_idx - 2].line == line &&
exec_trace[trace_idx - 3].line == line &&
exec_trace[trace_idx - 4].line == line)
{
int i;
printf("loop detected in line %d!\n", line);
for (i = trace_idx - 1; i >= 0; i--) {
if (exec_trace[i].type == fun_entry) {
printf("most recently entered function: %lx (%s) at line %d\n",
(unsigned long) exec_trace[i].function,
exec_trace[i].fname,
exec_trace[i].line);
break;
}
}
longjmp(abort_jmp, 1);
}
}
}
#define record_entry(F) \
record_trace(fun_entry, (word) (F), __LINE__, __func__)
#define record_exit(F) \
record_trace(fun_exit, (word) (F), __LINE__, __func__)
#define record_statement(S) do { \
record_trace(statement, 0, __LINE__, 0); \
S \
} while (0)
static void H_Hat(word P)
{
word Input_Halts;
record_entry(H_Hat);
Input_Halts = Halts(P, P);
if (Input_Halts)
for(;;)
record_statement();
record_exit(H_Hat);
}
static word Halts(word P, word I)
{
record_entry(Halts);
if (trace_idx == 2) {
/* local abort catch */
if (setjmp(abort_jmp) == 0) {
printf("Halts calling %lx(%lx)\n",
(unsigned long) P, (unsigned long) I);
((void (*)(word)) P) (I);
printf("Call to %lx(%lx) returned\n",
(unsigned long) P, (unsigned long) I);
record_exit(Halts);
return 1;
} else {
printf("Call to %lx(%lx) aborted due to runaway recursion!\n",
(unsigned long) P, (unsigned long) I);
record_exit(Halts);
return 0;
}
} else if (trace_idx > 8 && exec_trace[trace_idx - 2].function == (word) P) {
puts("runaway recursion detected!");
record_exit(Halts);
longjmp(abort_jmp, 1);
} else {
printf("Halts calling %lx(%lx)\n",
(unsigned long) P, (unsigned long) I);
((void (*)(word)) P) (I);
printf("Call to %lx(%lx) returned\n",
(unsigned long) P, (unsigned long) I);
record_exit(Halts);
return 1;
}
}
int main(int argc, char **argv)
{
record_entry(main);
/* Global abort catch */
if (setjmp(abort_jmp) == 0) {
if (argc >= 2 && strcmp(argv[1], "-h") == 0) {
puts("calling H_Hat(H_Hat)");
H_Hat((word) H_Hat);
puts("H_Hat(H_Hat) returned!");
} else if (argc >= 2 && strcmp(argv[1], "-l") == 0) {
again:
record_statement(goto again;);
} else {
word Input_Halts = Halts((word) H_Hat, (word) H_Hat);
printf("Input_Halts = %ld\n", (long) Input_Halts);
}
} else {
puts("aborting");
abort();
}
record_exit(main);
return 0;
}
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-30 12:46 -0400 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (the power of C)(halt decider code) |
| Message-ID | <2CI8I.245752$cS6.91963@fx34.iad> |
| In reply to | #30347 |
On 3/30/21 10:43 AM, olcott wrote: > On 3/30/2021 7:09 AM, Richard Damon wrote: >> On 3/30/21 12:24 AM, olcott wrote: >> >> If I try to rhun that code, as it stands, I will get a set of linker >> errors, because it uses functionality that is not included. >> > > I had to strip out a lot of the infrastructure so that the gist of the > idea would be not hidden in a myriad of details. And when you include that code, it become part of the Turing Machine and is thus INSIDE H^ and not outside it and able to affect its operation outside of the computation H. > >> THAT is the piece that you can't do in Turing Machines, because you >> really can't do that in C either. You need ALL the code. >> >> When you include all the code, you now get a complete computation that >> is the Turing Machine equivalent, and then you can perform that H^ >> transformation to that FULL Program. >> >> Note, this means H_Hat is a stand alone program, not a piece of code >> that runs under the x86utm 'os'. >> > > So in other words the static variables are OK? > > // This invokes a function based on 900 pages of source code > DebugStep(master_state, slave_state); > static variables are OK for communicating WITHIN a give computation. This is why each level of operation really needs its own totally independent code and data segments. One invocation of Halts can't get information from a version of Halts higher than itself. Also, one thing to note, is that really only the outer most invocation of Halts is actually in existence, everything inside it is actually just its simulation to make a decision, which really means we don't have an infinite recursion, but an infinite loop inside Halts. Halts actually doesn't 'call' H_Hat, but it simulates it.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-30 14:53 +0100 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (Computability!) |
| Message-ID | <87k0poych8.fsf@bsb.me.uk> |
| In reply to | #30327 |
André G. Isaak <agisaak@gm.invalid> writes: > On 2021-03-29 20:12, olcott wrote: >> My halting function requires static local memory, if Turing machines >> cannot simulate static local memory then the C language is strictly >> more powerful that a Turing machine because a C function with static >> local memory can keep track of its every invocation. > > You're really not event trying to get this, are you? I suspect he does get it. Maybe not in all the details, but he knows that a single self-contained algorithm H can't give the right answer for some specifically constricted computations, so he needs two "versions" of H. One 'inner' one needs to stop H^ and the outer one reports the halting status (incorrectly, though PO-correctly) of H^([H^]). He's been about as clear about this as someone with a business degree (and who hasn't studied the subject) could be reasonably expected to be. And of course everything he is doing can be realised in /a/ Turing machine, it just can't be realised as /two/ Turing machines, one getting the right answer (not the PO-right answer) about a correctly constructed "hat" version as he once claimed. All this mess is just what he's been doing to distract from the big lie of two and half years ago. Back then, he claimed to have something impossible (two actual Turing machines), but he didn't, and he's just be covering his tracks ever since. > ... the entire program in which foo is embedded will still likely > constitute a computation. Yes. When talking about a model based on something like a real CPU, it's programs -- fully compiled and linked programs -- and not functions that are computations. In part he may simply have been led astray by refusing to deal with representations (that's certainly part of the problem). You can't use the machine address of a function in some other program as the input to a proposed halt decider program. He'd have to provide the source as input, and he could not then make his two different computations. Of course he can try the same trick with whole programs provided he can find a way to interlink them (to get his two different computations) via the OS, but then it's the whole OS that is the computation, not the program anymore. He can keep this going for a decade or more. What he will never do is what he lied about having done two and half years ago. By the way, your explanations are very clear, thouh almost certainly going way over PO's head. I am replying to you simply because there is little point in talking to PO anymore, now that he has made the mistake of being clear. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-30 09:04 -0500 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (Computability!) |
| Message-ID | <NqednRqR8JZKsv79nZ2dnUU7-VHNnZ2d@giganews.com> |
| In reply to | #30341 |
On 3/30/2021 8:53 AM, Ben Bacarisse wrote: > André G. Isaak <agisaak@gm.invalid> writes: > >> On 2021-03-29 20:12, olcott wrote: > >>> My halting function requires static local memory, if Turing machines >>> cannot simulate static local memory then the C language is strictly >>> more powerful that a Turing machine because a C function with static >>> local memory can keep track of its every invocation. >> >> You're really not event trying to get this, are you? > > I suspect he does get it. Maybe not in all the details, but he knows > that a single self-contained algorithm H can't give the right answer for > some specifically constricted computations, so he needs two "versions" > of H. One 'inner' one needs to stop H^ and the outer one reports the > halting status (incorrectly, though PO-correctly) of H^([H^]). > > He's been about as clear about this as someone with a business degree > (and who hasn't studied the subject) could be reasonably expected to be. > > And of course everything he is doing can be realised in /a/ Turing > machine, it just can't be realised as /two/ Turing machines, one getting > the right answer (not the PO-right answer) about a correctly constructed > "hat" version as he once claimed. All this mess is just what he's been > doing to distract from the big lie of two and half years ago. Back > then, he claimed to have something impossible (two actual Turing > machines), but he didn't, and he's just be covering his tracks ever > since. > >> ... the entire program in which foo is embedded will still likely >> constitute a computation. > > Yes. When talking about a model based on something like a real CPU, > it's programs -- fully compiled and linked programs -- and not functions > that are computations. > > In part he may simply have been led astray by refusing to deal with > representations (that's certainly part of the problem). You can't use > the machine address of a function in some other program as the input to > a proposed halt decider program. Sure you can and RASP to TM equivalence proves this. Why says such stupid things that you know are false? > He'd have to provide the source as > input, and he could not then make his two different computations. > > Of course he can try the same trick with whole programs provided he can > find a way to interlink them (to get his two different computations) via > the OS, but then it's the whole OS that is the computation, not the > program anymore. He can keep this going for a decade or more. > > What he will never do is what he lied about having done two and half > years ago. > > By the way, your explanations are very clear, thouh almost certainly > going way over PO's head. I am replying to you simply because there is > little point in talking to PO anymore, now that he has made the mistake > of being clear. > -- 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-30 12:25 -0400 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (Computability!) |
| Message-ID | <giI8I.78984$t66.60784@fx38.iad> |
| In reply to | #30343 |
On 3/30/21 10:04 AM, olcott wrote: > On 3/30/2021 8:53 AM, Ben Bacarisse wrote: >> André G. Isaak <agisaak@gm.invalid> writes: >> >>> On 2021-03-29 20:12, olcott wrote: >> >>>> My halting function requires static local memory, if Turing machines >>>> cannot simulate static local memory then the C language is strictly >>>> more powerful that a Turing machine because a C function with static >>>> local memory can keep track of its every invocation. >>> >>> You're really not event trying to get this, are you? >> >> I suspect he does get it. Maybe not in all the details, but he knows >> that a single self-contained algorithm H can't give the right answer for >> some specifically constricted computations, so he needs two "versions" >> of H. One 'inner' one needs to stop H^ and the outer one reports the >> halting status (incorrectly, though PO-correctly) of H^([H^]). >> >> He's been about as clear about this as someone with a business degree >> (and who hasn't studied the subject) could be reasonably expected to be. >> >> And of course everything he is doing can be realised in /a/ Turing >> machine, it just can't be realised as /two/ Turing machines, one getting >> the right answer (not the PO-right answer) about a correctly constructed >> "hat" version as he once claimed. All this mess is just what he's been >> doing to distract from the big lie of two and half years ago. Back >> then, he claimed to have something impossible (two actual Turing >> machines), but he didn't, and he's just be covering his tracks ever >> since. >> >>> ... the entire program in which foo is embedded will still likely >>> constitute a computation. >> >> Yes. When talking about a model based on something like a real CPU, >> it's programs -- fully compiled and linked programs -- and not functions >> that are computations. >> >> In part he may simply have been led astray by refusing to deal with >> representations (that's certainly part of the problem). You can't use >> the machine address of a function in some other program as the input to >> a proposed halt decider program. > > > Sure you can and RASP to TM equivalence proves this. > Why says such stupid things that you know are false? > > Just remember that H^ will be OUTSIDE that RASP machine, and so each level of processing will create a NEW RASP machine with no contact to the ones above it. That RASP machine will need to be able to simulate Turing Machines that are not RASP Machines, or at the very least, a RASP program that runs in a distinct machine, so that comparing addresses might not be valid as it WILL be a different RASP program inside it.
[toc] | [prev] | [next] | [standalone]
| From | Andy Walker <anw@cuboid.co.uk> |
|---|---|
| Date | 2021-03-29 18:59 +0100 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (computability) |
| Message-ID | <s3t4i5$129j$1@gioia.aioe.org> |
| In reply to | #30241 |
On 29/03/2021 01:02, olcott wrote:
> On 3/28/2021 6:34 PM, Andy Walker wrote:
>>> To define an H that correctly decides H^ inherently requires that H
>>> be defined on the basis of a UTM that detects that itself has been
>>> invoked in infinite recursion.
>> There is no such requirement, inherent or otherwise; that is
> Except for the fact that every other alternative can't possibly work...
As there is no [full] halt decider, your approach isn't going
to work either, as has been pointed out to you many times, including
what your mistakes are.
> H only needs to be able to simulate its input
> one-instruction-at-a-time, keep a set of execution traces of this
> simulation, examine each trace after each instruction is simulated
> one-instruction-at-a-time, and detect when H^ calls H from the same
> machine address twice with no conditional branch instructions
> inbetween.
> To say that this is uncomputable is ridiculous.
No-one is saying that. Only that it gets the wrong answer [if
any] for "H_hat".
>> You can make "H", viewed as a C program, be
>> recursive if you like, but that's not inherent or in any way required.
> It is the only way that a halt decider can correctly decide halting on H^.
There is no halt decider, and a partial halt decider gets the
wrong answer [if any] for "H_hat", by the definition of "H_hat".
>> Nor is any UTM inherent in the process;
> It is the only way that a halt decider can correctly decide halting on H^.
See previous point.
>> again, you can use one if you
>> like, but it's an unnecessary complication,
> It is the only way that a halt decider can correctly decide halting on H^.
See previous point.
[...]
> People review my work on the basis of blah, blah, blah, I didn't see
> a single word of what you said but I know that you must be wrong.
They do know you must be wrong, and once people have pointed
out your mistakes, and been rebuffed by irrelevant guff, they CBA to
read more. If there was anything interesting on TV ATM, I wouldn't
bother either. But troll baiting is at least mildly amusing.
--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Mendelssohn
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-29 15:28 -0500 |
| Subject | Re: A UTM halt decider <is> a pure function of its inputs (learned-by-rote) |
| Message-ID | <yKqdnS7or4n8pf_9nZ2dnUU7-IvNnZ2d@giganews.com> |
| In reply to | #30290 |
On 3/29/2021 12:59 PM, Andy Walker wrote:
> On 29/03/2021 01:02, olcott wrote:
>> On 3/28/2021 6:34 PM, Andy Walker wrote:
>>>> To define an H that correctly decides H^ inherently requires that H
>>>> be defined on the basis of a UTM that detects that itself has been
>>>> invoked in infinite recursion.
>>> There is no such requirement, inherent or otherwise; that is
>> Except for the fact that every other alternative can't possibly work...
>
> As there is no [full] halt decider, your approach isn't going
> to work either, as has been pointed out to you many times, including
> what your mistakes are.
A full halt decider is not required to refute the conventional proofs
and you know it. Why lie?
As long as the halt decider correctly decides the computational
equivalent of the key basis of all the halting udecibility proofs:
"do the opposite of whatever the halt decider decides"
Now we construct a new Turing machine D with H as a
subroutine. This new TM calls H to determine what M
does when the input to M is its own description <M>.
Once D has determined this information, it does the
opposite.
That is, it rejects if M accepts and accepts
if M does not accept. (Sipser 1997:165)
Then this (at least partial) halt decider has refuted the proofs.
No dogmatic assertions to the contrary are ever any form of correct
rebuttal. The stupid mistake that you just made knowing full well that
it is a stupid mistake about requiring a full halt decider to refute the
conventional proofs merely makes you look foolish.
Sipser, Michael 1997. Introduction to the Theory of Computation. Boston:
PWS Publishing Company (165-167)
>> H only needs to be able to simulate its input
>> one-instruction-at-a-time, keep a set of execution traces of this
>> simulation, examine each trace after each instruction is simulated
>> one-instruction-at-a-time, and detect when H^ calls H from the same
>> machine address twice with no conditional branch instructions
>> inbetween.
>> To say that this is uncomputable is ridiculous.
>
> No-one is saying that. Only that it gets the wrong answer [if
> any] for "H_hat".
>
>>> You can make "H", viewed as a C program, be
>>> recursive if you like, but that's not inherent or in any way required.
>> It is the only way that a halt decider can correctly decide halting on
>> H^.
>
> There is no halt decider, and a partial halt decider gets the
> wrong answer [if any] for "H_hat", by the definition of "H_hat".
>
>>> Nor is any UTM inherent in the process;
>> It is the only way that a halt decider can correctly decide halting on
>> H^.
>
> See previous point.
>
>>> again, you can use one if you
>>> like, but it's an unnecessary complication,
>> It is the only way that a halt decider can correctly decide halting on
>> H^.
>
> See previous point.
>
> [...]
>> People review my work on the basis of blah, blah, blah, I didn't see
>> a single word of what you said but I know that you must be wrong.
>
> They do know you must be wrong, and once people have pointed
> out your mistakes, and been rebuffed by irrelevant guff, they CBA to
> read more. If there was anything interesting on TV ATM, I wouldn't
> bother either. But troll baiting is at least mildly amusing.
>
People have said that access to global data proves that a sequence of
programming steps is not a computation even though TM's do access their
own global data and are computations.
Richard Damon was the only one that understood this beyond
learned-by-rote from-the-book to explain that complete programs can
access their own global data and still meet the requirements of a
computation. No one else understood this, they could only parrot their
learned-by-rote from-the-book.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 19 of 36 — ← Prev page 1 … 17 18 [19] 20 21 … 36 Next page →
Back to top | Article view | comp.theory
csiph-web