Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #24537 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-10-27 14:30 -0500 |
| Last post | 2020-10-29 19:40 +0100 |
| Articles | 20 on this page of 145 — 15 participants |
Back to article view | Back to comp.theory
Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 14:30 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 13:46 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 15:02 -0500
Re: Architectural design of a halting problem solution Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 20:03 +0000
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 15:13 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 14:34 -0600
Re: Architectural design of a halting problem solution Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 21:11 +0000
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 16:27 -0500
Re: Architectural design of a halting problem solution Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-27 21:33 +0000
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 16:57 -0500
Re: Architectural design of a halting problem solution Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 14:44 -0700
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 16:54 -0500
Re: Architectural design of a halting problem solution Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-27 15:07 -0700
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 18:43 -0500
Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-27 21:45 -0400
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 21:28 -0500
Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-27 22:48 -0400
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 21:55 -0500
Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-28 09:04 -0400
Re: Architectural design of a halting problem solution Mostowski Collapse <janburse@fastmail.fm> - 2020-10-28 14:13 +0100
Re: Architectural design of a halting problem solution David Brown <david.brown@hesbynett.no> - 2020-10-28 15:12 +0100
Re: Architectural design of a halting problem solution Mostowski Collapse <janburse@fastmail.fm> - 2020-10-28 14:13 +0100
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 18:18 -0500
Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-10-28 09:38 +0000
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 17:54 -0500
Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-10-29 06:59 +0000
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 07:28 -0500
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 07:35 -0500
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-27 16:23 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 22:49 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 00:05 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 23:25 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 00:31 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-27 23:55 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 17:50 -0500
Re: Architectural design of a halting problem solution Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-28 23:27 +0000
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-28 21:09 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 00:45 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 07:18 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 07:30 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 11:05 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 10:55 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 12:52 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 11:58 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 13:25 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 12:56 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 14:13 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 13:50 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 15:18 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 14:52 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 16:18 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-30 08:53 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-30 10:55 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-31 08:28 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 09:53 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-31 09:23 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 10:35 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-31 09:44 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 11:03 -0500
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-11-01 07:46 -0700
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-11-01 12:12 -0600
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-11-01 12:45 -0600
Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-31 14:46 -0400
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 13:57 -0500
Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-31 16:00 -0400
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 15:34 -0500
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 15:42 -0500
Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-10-31 21:07 +0000
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 16:19 -0500
Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-10-31 21:33 +0000
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 16:50 -0500
Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-31 18:31 -0400
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-10-31 17:50 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 19:53 -0400
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-10-31 19:19 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 21:19 -0400
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-10-31 22:22 -0400
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-10-31 21:36 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-10-31 22:18 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 08:19 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 08:40 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-01 16:11 +0000
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 12:18 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-01 19:50 +0000
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 14:09 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 14:38 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-01 21:32 +0000
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 15:54 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 00:46 +0000
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 19:05 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 19:10 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 21:57 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 22:33 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-02 08:53 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 08:04 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-02 10:45 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 03:00 +0000
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 22:32 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 20:55 +0000
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 15:20 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 16:20 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 01:16 +0000
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 19:28 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-02 03:15 +0000
Re: Architectural design of a halting problem solution [ Adaptation of Ben's code simplifications ] olcott <NoOne@NoWhere.com> - 2020-11-01 22:20 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-02 03:02 +0000
Re: Architectural design of a halting problem solution [ one paragraph says it all ] olcott <NoOne@NoWhere.com> - 2020-11-01 21:55 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 22:25 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-02 02:45 +0000
Re: Architectural design of a halting problem solution [ non halting behavior detected ] olcott <NoOne@NoWhere.com> - 2020-11-01 23:14 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-02 03:12 -0800
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] André G. Isaak <agisaak@gm.invalid> - 2020-11-02 04:52 -0700
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 08:01 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] André G. Isaak <agisaak@gm.invalid> - 2020-11-02 08:12 -0700
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-02 10:23 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-02 07:58 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 14:02 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 17:52 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 17:59 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Richard Damon <Richard@Damon-Family.org> - 2020-11-01 21:38 -0500
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 21:05 -0600
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-02 00:17 +0000
Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] olcott <NoOne@NoWhere.com> - 2020-11-01 19:53 -0600
Re: Architectural design of a halting problem solution Alan Mackenzie <acm@muc.de> - 2020-11-01 08:29 +0000
Re: Architectural design of a halting problem solution Richard Damon <Richard@Damon-Family.org> - 2020-10-31 18:28 -0400
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 17:42 -0500
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-31 15:47 -0500
Re: Architectural design of a halting problem solution Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-29 13:13 -0700
Re: Architectural design of a halting problem solution André G. Isaak <agisaak@gm.invalid> - 2020-10-29 14:46 -0600
Re: Architectural design of a halting problem solution Andy Walker <anw@cuboid.co.uk> - 2020-10-29 14:41 +0000
Re: Architectural design of a halting problem solution olcott <NoOne@NoWhere.com> - 2020-10-29 10:29 -0500
Re: Architectural design of a halting problem solution Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-28 04:17 +0000
Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 14:00 +0100
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2020-10-29 08:48 -0600
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-29 15:17 +0000
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) olcott <NoOne@NoWhere.com> - 2020-10-29 11:13 -0500
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-29 16:39 +0000
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Manfred <noname@add.invalid> - 2020-10-29 19:20 +0100
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-29 18:55 +0000
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) David Brown <david.brown@hesbynett.no> - 2020-10-30 11:02 +0100
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-30 10:52 +0000
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Jorgen Grahn <grahn+nntp@snipabacken.se> - 2020-10-30 19:47 +0000
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Ralf Goertz <me@myprovider.invalid> - 2020-10-30 12:55 +0100
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-30 16:33 +0000
Re: Stop crossposting you imbecil spammer (Re: Architectural design of a halting problem solution Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 19:40 +0100
Page 5 of 8 — ← Prev page 1 2 3 4 [5] 6 7 8 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-01 08:40 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <x6SdnZwKP6BfVQPCnZ2dnUU7-c_NnZ2d@giganews.com> |
| In reply to | #24779 |
On 11/1/2020 7:19 AM, Richard Damon wrote: > On 10/31/20 11:18 PM, olcott wrote: >> >> It is apparently over your head that the above code specifies three >> different instances of H_Hat and that >> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly >> decide one of these three different instances. > > You seem to be unaware that H_Hat is a Turing machine, and as such there > is but one definition of it. It can have one Turing Machine description that is executed multiple times by a master Turing machine. Each of these instances can have different amounts of data on their local tape. So it is exactly the same thing as three different instances of H_Hat each in their own local process context. > There is one embodiment of it as an actual machine in the probem, and > multiple copies of a representation of it, suitable for H to process. If we think of all of the machines involved as Turing Machine descriptions of UTMs that are executed by a single master UTM then we can get rid of the tedious dichotomy of a machine and its description and simply talk about machines that can execute other machines. In m y x86utm operting system the machine description language is x86 and it is always directly executable. > For a given input, H_Hat will always produce the same result, that is a > fundamental property of Turing Machines. Yet with three different instances of the same machine each one having a longer execution trace the outermost invocation has the data required to make its halting decision first. As soon as it terminates its subordinate the entire process chain stops running. > If your 'UTM' gets a different answer when simulating the machine, then > that is positive evidence that your UTM has a bug. The answer H gives Three identical function with different amounts of data can and do derive different results. The first one with complete data to make a decision terminates the whole process chain of all the rest. > must match that actual answer that running the REAL H_Hat gives. If > other instances act different, all that shows is that somewhere there is > a discrepancy that invalidates the example. > H_Hat(H_Hat) There are three different instances of H_Hat having different lengths of the execution trace of its subordinate. The halt decider has no data regarding the execution trace of the first H_Hat because it has not been invoked yet. When it is invoked if begins to acquire data regarding the execution trace of its first parameter. As soon as it has a sufficiently long execution trace it makes it halting decision. None of the instances of H_Hat directly have any data about the execution trace of their input. All of this execution trace data is held in the halt decider that they invoke: bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); If we construe that an H_Hat instance has the data of the halt decider that it invoked by proxy then no halt decider has any data about the outermost H_Hat. The outermost H_Hat though its halt decider has the execution trace data of its input. This is the longest execution trace thus the most data. Each subsequent H_Hat halt decider has decreasingly less data. The halt decider for out outermost H_Hat does not exist so it has no data. The halt decider for the H_Hat parameter to the outermost H_Hat has the most data. The subsequent invocations of halt deciders and H_Hat has increasingly less data. So the reason why the different H_Hats have different behavior is they have a different amount of data. There is zero data about the execution trace of the first H_Hat. There is the most data about the execution trace of the next _H_Hat and there is less data about the execution trace of the third H_Hat. The first halt decider has the most data about the execution trace of any instance of H_Hat thus providing the legitimate reason why its behavior differs. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-01 16:11 +0000 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <dIqdna5UecSgQwPCnZ2dnUU78V_NnZ2d@brightview.co.uk> |
| In reply to | #24782 |
On 01/11/2020 14:40, olcott wrote: > On 11/1/2020 7:19 AM, Richard Damon wrote: >> On 10/31/20 11:18 PM, olcott wrote: >>> >>> It is apparently over your head that the above code specifies three >>> different instances of H_Hat and that >>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly >>> decide one of these three different instances. >> >> You seem to be unaware that H_Hat is a Turing machine, and as such there >> is but one definition of it. > > It can have one Turing Machine description that is executed multiple > times by a master Turing machine. Each of these instances can have > different amounts of data on their local tape. > > So it is exactly the same thing as three different instances of H_Hat > each in their own local process context. > >> There is one embodiment of it as an actual machine in the probem, and >> multiple copies of a representation of it, suitable for H to process. > > If we think of all of the machines involved as Turing Machine > descriptions of UTMs that are executed by a single master UTM then we > can get rid of the tedious dichotomy of a machine and its description > and simply talk about machines that can execute other machines. > > In m y x86utm operting system the machine description language is x86 > and it is always directly executable. > >> For a given input, H_Hat will always produce the same result, that is a >> fundamental property of Turing Machines. > > Yet with three different instances of the same machine each one having a > longer execution trace the outermost invocation has the data required > to make its halting decision first. As soon as it terminates its > subordinate the entire process chain stops running. The calculation H-Hat(H_Hat) as you have described it elsewhere halts (in some finite number of steps it reaches a halt state - you haven't denied this, bearing in mind we're talking of the HP/Linz defined term "halts"). Let's imagine, just for illustrative purposes, that it halts in 10000 steps. That's to say, 10000 /specific/ steps, each one consisting of one specific program state (current instruction within the program) together with its data state. We could write all these down exactly, if we could be bothered, and had a big enough notebook! The final step 10000 is of course the calculation's halt state. EVERY ONE OF YOUR EMULATIONS OF H_HAT ARE SIMPLY IN THE PROCESS OF ENUMERATING THE 10000 STATES OF THIS ONE SINGLE CALCULATION. The only difference between them is that at a given point in the (outer) H_Hat or H calculation, they will each have enumerated a different number of these steps. Maybe the outer one has enumerated the first 7000 steps out of the total 10000, while an inner one has only enumerated 2000 of the same 10000 states, or whatever. At this point, let's say the outer emulation process decides to stop emulating for whatever reason - its seen enough! So the emulation only ever enumerates 7000 of the 10000 steps. (Inner emulations enumerate less.) If you want to say that all the emulations had "different results" then all you're saying is that each proceeded for a different number of steps along one and the same calculation (which contains 10000 steps and then halts, however you try to confuse things). > >> If your 'UTM' gets a different answer when simulating the machine, then >> that is positive evidence that your UTM has a bug. The answer H gives > > Three identical function with different amounts of data can and do > derive different results. You mean, each emulation can be abandonned after enumerating a different number of steps before its emulator gives up. (The underlying calculation they are enumerating in each case is the same. In our illustration it is a calculation with 10000 steps, the last being the halt state for the calculation.) > The first one with complete data to make a > decision terminates the whole process chain of all the rest. > >> must match that actual answer that running the REAL H_Hat gives. If >> other instances act different, all that shows is that somewhere there is >> a discrepancy that invalidates the example. >> > > H_Hat(H_Hat) > There are three different instances of H_Hat having different lengths of > the execution trace of its subordinate. The halt decider has no data > regarding the execution trace of the first H_Hat because it has not been > invoked yet. When it is invoked if begins to acquire data regarding the > execution trace of its first parameter. As soon as it has a sufficiently > long execution trace it makes it halting decision. > You have said that its decision is not a "halting/non-halting" decision in the sense of HP/Linz proof. I.e. it is not a decision on whether its input is in class HALTING or NON_HALTING. (Those classes being the calculation that eventually reach a halt state, or don't, respectively.) Continuing the earlier illustration, the outer emulation was abandoned after enumerating only 7000 of the full 10000 steps in the calculation, because the internal code decided it had found evidence of non-halting behaviour. Clearly that evidence was wrong in any meaningful sense, because in 10000 steps the calculation reaches a halt step. There's no arguing with that - I've got each of those 10000 explicit steps written down exactly, in my notebood! :) And look, step 10000 is indeed a halt state, so the calculation DOES halt. Whatever you are deciding, it's not whether the input is in the NON_HALTING class. Somehow you have just become confused and are looking at this incorrectly. You say the calculation /only/ terminates in 10000 steps /because/ of the way its program is written (something about the internal ABNHBD choosing to abandon its emulation after 7000 steps). That doesn't matter - the calculation /does/ halt in 10000 steps. Internal emulations may be abandoned when only 7000 steps have been enumerated, but nobody but you cares about that! The fact that if we replace H_Hat with H_Hat_2 [a different program, where its internal routine ABNHBD lacks the "non-terminating behaviour" test] then calculation H_Hat_2(H_Hat_2) doesn't halt is also quite irrelevant. If your argument is that ABNHBD in H or H_Hat returned the "correct" result, because ABNHBD did indeed abort its emulation after looking at only 7000 of the 10000 steps in the calculation, then you would only be saying that H is a "did my internal routine think it had found non-terminating behaviour" decider. Nobody is interested in that. (It would be a totally crass argument, not refuting anything.) Mike. > None of the instances of H_Hat directly have any data about the > execution trace of their input. All of this execution trace data is > held in the halt decider that they invoke: > bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat); > > If we construe that an H_Hat instance has the data of the halt decider > that it invoked by proxy then no halt decider has any data about the > outermost H_Hat. The outermost H_Hat though its halt decider has the > execution trace data of its input. This is the longest execution trace > thus the most data. Each subsequent H_Hat halt decider has decreasingly > less data. > > The halt decider for out outermost H_Hat does not exist so it has no > data. The halt decider for the H_Hat parameter to the outermost H_Hat > has the most data. The subsequent invocations of halt deciders and H_Hat > has increasingly less data. > > So the reason why the different H_Hats have different behavior is they > have a different amount of data. There is zero data about the execution > trace of the first H_Hat. There is the most data about the execution > trace of the next _H_Hat and there is less data about the execution > trace of the third H_Hat. > > The first halt decider has the most data about the execution trace of > any instance of H_Hat thus providing the legitimate reason why its > behavior differs. >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-01 12:18 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <0e-dnRdIEbOYYQPCnZ2dnUU7-RnNnZ2d@giganews.com> |
| In reply to | #24784 |
On 11/1/2020 10:11 AM, Mike Terry wrote:
> On 01/11/2020 14:40, olcott wrote:
>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>
>>>> It is apparently over your head that the above code specifies three
>>>> different instances of H_Hat and that
>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly
>>>> decide one of these three different instances.
>>>
>>> You seem to be unaware that H_Hat is a Turing machine, and as such there
>>> is but one definition of it.
>>
>> It can have one Turing Machine description that is executed multiple
>> times by a master Turing machine. Each of these instances can have
>> different amounts of data on their local tape.
>>
>> So it is exactly the same thing as three different instances of H_Hat
>> each in their own local process context.
>>
>>> There is one embodiment of it as an actual machine in the probem, and
>>> multiple copies of a representation of it, suitable for H to process.
>>
>> If we think of all of the machines involved as Turing Machine
>> descriptions of UTMs that are executed by a single master UTM then we
>> can get rid of the tedious dichotomy of a machine and its description
>> and simply talk about machines that can execute other machines.
>>
>> In m y x86utm operting system the machine description language is x86
>> and it is always directly executable.
>>
>>> For a given input, H_Hat will always produce the same result, that is a
>>> fundamental property of Turing Machines.
>>
>> Yet with three different instances of the same machine each one having a
>> longer execution trace the outermost invocation has the data required
>> to make its halting decision first. As soon as it terminates its
>> subordinate the entire process chain stops running.
>
> The calculation H-Hat(H_Hat) as you have described it elsewhere halts
> (in some finite number of steps it reaches a halt state - you haven't
> denied this, bearing in mind we're talking of the HP/Linz defined term
> "halts").
int main()
{
H_Hat(H_Hat)
invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
which correctly decides that its first parameter would never halt unless
its execution is terminated.
Everything else that you say is moot until you first understand the
details related to what I just said prove that what I just said is true.
> Let's imagine, just for illustrative purposes, that it halts in 10000
> steps. That's to say, 10000 /specific/ steps, each one consisting of
> one specific program state (current instruction within the program)
> together with its data state. We could write all these down exactly, if
> we could be bothered, and had a big enough notebook! The final step
> 10000 is of course the calculation's halt state.
>
> EVERY ONE OF YOUR EMULATIONS OF H_HAT ARE SIMPLY IN THE PROCESS OF
> ENUMERATING THE 10000 STATES OF THIS ONE SINGLE CALCULATION.
>
> The only difference between them is that at a given point in the (outer)
> H_Hat or H calculation, they will each have enumerated a different
> number of these steps. Maybe the outer one has enumerated the first
> 7000 steps out of the total 10000, while an inner one has only
> enumerated 2000 of the same 10000 states, or whatever.
>
> At this point, let's say the outer emulation process decides to stop
> emulating for whatever reason - its seen enough! So the emulation only
> ever enumerates 7000 of the 10000 steps. (Inner emulations enumerate
> less.)
>
> If you want to say that all the emulations had "different results" then
> all you're saying is that each proceeded for a different number of steps
> along one and the same calculation (which contains 10000 steps and then
> halts, however you try to confuse things).
>
>>
>>> If your 'UTM' gets a different answer when simulating the machine, then
>>> that is positive evidence that your UTM has a bug. The answer H gives
>>
>> Three identical function with different amounts of data can and do
>> derive different results.
>
> You mean, each emulation can be abandonned after enumerating a different
> number of steps before its emulator gives up. (The underlying
> calculation they are enumerating in each case is the same. In our
> illustration it is a calculation with 10000 steps, the last being the
> halt state for the calculation.)
>
>> The first one with complete data to make a
>> decision terminates the whole process chain of all the rest.
>>
>>> must match that actual answer that running the REAL H_Hat gives. If
>>> other instances act different, all that shows is that somewhere there is
>>> a discrepancy that invalidates the example.
>>>
>>
>> H_Hat(H_Hat)
>> There are three different instances of H_Hat having different lengths of
>> the execution trace of its subordinate. The halt decider has no data
>> regarding the execution trace of the first H_Hat because it has not been
>> invoked yet. When it is invoked if begins to acquire data regarding the
>> execution trace of its first parameter. As soon as it has a sufficiently
>> long execution trace it makes it halting decision.
>>
>
> You have said that its decision is not a "halting/non-halting" decision
> in the sense of HP/Linz proof. I.e. it is not a decision on whether its
> input is in class HALTING or NON_HALTING. (Those classes being the
> calculation that eventually reach a halt state, or don't, respectively.)
>
> Continuing the earlier illustration, the outer emulation was abandoned
> after enumerating only 7000 of the full 10000 steps in the calculation,
> because the internal code decided it had found evidence of non-halting
> behaviour. Clearly that evidence was wrong in any meaningful sense,
> because in 10000 steps the calculation reaches a halt step.
>
> There's no arguing with that - I've got each of those 10000 explicit
> steps written down exactly, in my notebood! :) And look, step 10000 is
> indeed a halt state, so the calculation DOES halt. Whatever you are
> deciding, it's not whether the input is in the NON_HALTING class.
>
> Somehow you have just become confused and are looking at this
> incorrectly. You say the calculation /only/ terminates in 10000 steps
> /because/ of the way its program is written (something about the
> internal ABNHBD choosing to abandon its emulation after 7000 steps).
> That doesn't matter - the calculation /does/ halt in 10000 steps.
> Internal emulations may be abandoned when only 7000 steps have been
> enumerated, but nobody but you cares about that!
>
> The fact that if we replace H_Hat with H_Hat_2 [a different program,
> where its internal routine ABNHBD lacks the "non-terminating behaviour"
> test] then calculation H_Hat_2(H_Hat_2) doesn't halt is also quite
> irrelevant.
>
> If your argument is that ABNHBD in H or H_Hat returned the "correct"
> result, because ABNHBD did indeed abort its emulation after looking at
> only 7000 of the 10000 steps in the calculation, then you would only be
> saying that H is a "did my internal routine think it had found
> non-terminating behaviour" decider. Nobody is interested in that. (It
> would be a totally crass argument, not refuting anything.)
>
> Mike.
>
>
>> None of the instances of H_Hat directly have any data about the
>> execution trace of their input. All of this execution trace data is
>> held in the halt decider that they invoke:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>
>> If we construe that an H_Hat instance has the data of the halt decider
>> that it invoked by proxy then no halt decider has any data about the
>> outermost H_Hat. The outermost H_Hat though its halt decider has the
>> execution trace data of its input. This is the longest execution trace
>> thus the most data. Each subsequent H_Hat halt decider has decreasingly
>> less data.
>>
>> The halt decider for out outermost H_Hat does not exist so it has no
>> data. The halt decider for the H_Hat parameter to the outermost H_Hat
>> has the most data. The subsequent invocations of halt deciders and H_Hat
>> has increasingly less data.
>>
>> So the reason why the different H_Hats have different behavior is they
>> have a different amount of data. There is zero data about the execution
>> trace of the first H_Hat. There is the most data about the execution
>> trace of the next _H_Hat and there is less data about the execution
>> trace of the third H_Hat.
>>
>> The first halt decider has the most data about the execution trace of
>> any instance of H_Hat thus providing the legitimate reason why its
>> behavior differs.
>>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-01 19:50 +0000 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <CYadnWgG6ZcajALCnZ2dnUU78I3NnZ2d@brightview.co.uk> |
| In reply to | #24788 |
On 01/11/2020 18:18, olcott wrote:
> On 11/1/2020 10:11 AM, Mike Terry wrote:
>> On 01/11/2020 14:40, olcott wrote:
>>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>>
>>>>> It is apparently over your head that the above code specifies three
>>>>> different instances of H_Hat and that
>>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly
>>>>> decide one of these three different instances.
>>>>
>>>> You seem to be unaware that H_Hat is a Turing machine, and as such
>>>> there
>>>> is but one definition of it.
>>>
>>> It can have one Turing Machine description that is executed multiple
>>> times by a master Turing machine. Each of these instances can have
>>> different amounts of data on their local tape.
>>>
>>> So it is exactly the same thing as three different instances of H_Hat
>>> each in their own local process context.
>>>
>>>> There is one embodiment of it as an actual machine in the probem, and
>>>> multiple copies of a representation of it, suitable for H to process.
>>>
>>> If we think of all of the machines involved as Turing Machine
>>> descriptions of UTMs that are executed by a single master UTM then we
>>> can get rid of the tedious dichotomy of a machine and its description
>>> and simply talk about machines that can execute other machines.
>>>
>>> In m y x86utm operting system the machine description language is x86
>>> and it is always directly executable.
>>>
>>>> For a given input, H_Hat will always produce the same result, that is a
>>>> fundamental property of Turing Machines.
>>>
>>> Yet with three different instances of the same machine each one having a
>>> longer execution trace the outermost invocation has the data required
>>> to make its halting decision first. As soon as it terminates its
>>> subordinate the entire process chain stops running.
>>
>> The calculation H-Hat(H_Hat) as you have described it elsewhere halts
>> (in some finite number of steps it reaches a halt state - you haven't
>> denied this, bearing in mind we're talking of the HP/Linz defined term
>> "halts").
>
> int main()
> {
> H_Hat(H_Hat)
>
> invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
> which correctly decides that its first parameter would never halt unless
> its execution is terminated.
>
> Everything else that you say is moot until you first understand the
> details related to what I just said prove that what I just said is true.
LOL, but they don't.
You say that everything else I'm saying is moot, but that's just your
way of avoiding having to take on board any reasoning that leads towards
the conclusion that you're wrong. Similarly with your "unresponsive"
answers to others' questions - you know, when you just change the
subject and cut-and-paste stock phrases which you've repeated over and
over, which in no way address the questions asked.
It doesn't matter to me that you don't want to listen to people
explaining your mistakes - cranks never do. My prediction when I made
the previous post was that you would read half a dozen lines, then make
some dismissive remark excusing you from thinking any further. This is
your ages old pattern of behaviour, and as ever you are true to form. :)
By all means ignore all feedback - just continue with your plan to
publish your result and claim the recognition and credibility you feel
you deserve. You've been trying for some years for this, and you feel
it's coming, yet somehow it's never quite arrived! I'm happy for you
that you feel the culmination of you life's work is nearly at hand, and
you will finally get what's been coming to you for so long...
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-01 14:09 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <NfOdnQjW55afiwLCnZ2dnUU7-a_NnZ2d@giganews.com> |
| In reply to | #24794 |
On 11/1/2020 1:50 PM, Mike Terry wrote:
> On 01/11/2020 18:18, olcott wrote:
>> On 11/1/2020 10:11 AM, Mike Terry wrote:
>>> On 01/11/2020 14:40, olcott wrote:
>>>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>>>
>>>>>> It is apparently over your head that the above code specifies three
>>>>>> different instances of H_Hat and that
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly
>>>>>> decide one of these three different instances.
>>>>>
>>>>> You seem to be unaware that H_Hat is a Turing machine, and as such
>>>>> there
>>>>> is but one definition of it.
>>>>
>>>> It can have one Turing Machine description that is executed multiple
>>>> times by a master Turing machine. Each of these instances can have
>>>> different amounts of data on their local tape.
>>>>
>>>> So it is exactly the same thing as three different instances of H_Hat
>>>> each in their own local process context.
>>>>
>>>>> There is one embodiment of it as an actual machine in the probem, and
>>>>> multiple copies of a representation of it, suitable for H to process.
>>>>
>>>> If we think of all of the machines involved as Turing Machine
>>>> descriptions of UTMs that are executed by a single master UTM then we
>>>> can get rid of the tedious dichotomy of a machine and its description
>>>> and simply talk about machines that can execute other machines.
>>>>
>>>> In m y x86utm operting system the machine description language is x86
>>>> and it is always directly executable.
>>>>
>>>>> For a given input, H_Hat will always produce the same result, that
>>>>> is a
>>>>> fundamental property of Turing Machines.
>>>>
>>>> Yet with three different instances of the same machine each one
>>>> having a
>>>> longer execution trace the outermost invocation has the data required
>>>> to make its halting decision first. As soon as it terminates its
>>>> subordinate the entire process chain stops running.
>>>
>>> The calculation H-Hat(H_Hat) as you have described it elsewhere halts
>>> (in some finite number of steps it reaches a halt state - you haven't
>>> denied this, bearing in mind we're talking of the HP/Linz defined term
>>> "halts").
>>
>> int main()
>> {
>> H_Hat(H_Hat)
>>
>> invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>> which correctly decides that its first parameter would never halt unless
>> its execution is terminated.
>>
>> Everything else that you say is moot until you first understand the
>> details related to what I just said prove that what I just said is true.
>
> LOL, but they don't.
It is a verifiable fact that
Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
correctly decides that its first parameter would never halt unless
its execution is terminated.
If you want to dismiss verifiable facts as irrelevant details this would
prove that you are dishonest.
If you are not sufficiently convinced that this is a verifiable fact
then I will verify it in greater detail.
Since knowing the truth of this statement is the mandatory prerequisite
to understanding what I am saying we must have mutual agreement on this
key point before proceeding to any other points.
> You say that everything else I'm saying is moot, but that's just your
> way of avoiding having to take on board any reasoning that leads towards
> the conclusion that you're wrong. Similarly with your "unresponsive"
> answers to others' questions - you know, when you just change the
> subject and cut-and-paste stock phrases which you've repeated over and
> over, which in no way address the questions asked.
>
> It doesn't matter to me that you don't want to listen to people
> explaining your mistakes - cranks never do. My prediction when I made
> the previous post was that you would read half a dozen lines, then make
> some dismissive remark excusing you from thinking any further. This is
> your ages old pattern of behaviour, and as ever you are true to form. :)
>
> By all means ignore all feedback - just continue with your plan to
> publish your result and claim the recognition and credibility you feel
> you deserve. You've been trying for some years for this, and you feel
> it's coming, yet somehow it's never quite arrived! I'm happy for you
> that you feel the culmination of you life's work is nearly at hand, and
> you will finally get what's been coming to you for so long...
>
> Mike.
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-01 14:38 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <X6edncHKE4EvgQLCnZ2dnUU7-SHNnZ2d@giganews.com> |
| In reply to | #24794 |
On 11/1/2020 1:50 PM, Mike Terry wrote:
> On 01/11/2020 18:18, olcott wrote:
>> On 11/1/2020 10:11 AM, Mike Terry wrote:
>>> On 01/11/2020 14:40, olcott wrote:
>>>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>>>
>>>>>> It is apparently over your head that the above code specifies three
>>>>>> different instances of H_Hat and that
>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly
>>>>>> decide one of these three different instances.
>>>>>
>>>>> You seem to be unaware that H_Hat is a Turing machine, and as such
>>>>> there
>>>>> is but one definition of it.
>>>>
>>>> It can have one Turing Machine description that is executed multiple
>>>> times by a master Turing machine. Each of these instances can have
>>>> different amounts of data on their local tape.
>>>>
>>>> So it is exactly the same thing as three different instances of H_Hat
>>>> each in their own local process context.
>>>>
>>>>> There is one embodiment of it as an actual machine in the probem, and
>>>>> multiple copies of a representation of it, suitable for H to process.
>>>>
>>>> If we think of all of the machines involved as Turing Machine
>>>> descriptions of UTMs that are executed by a single master UTM then we
>>>> can get rid of the tedious dichotomy of a machine and its description
>>>> and simply talk about machines that can execute other machines.
>>>>
>>>> In m y x86utm operting system the machine description language is x86
>>>> and it is always directly executable.
>>>>
>>>>> For a given input, H_Hat will always produce the same result, that
>>>>> is a
>>>>> fundamental property of Turing Machines.
>>>>
>>>> Yet with three different instances of the same machine each one
>>>> having a
>>>> longer execution trace the outermost invocation has the data required
>>>> to make its halting decision first. As soon as it terminates its
>>>> subordinate the entire process chain stops running.
>>>
>>> The calculation H-Hat(H_Hat) as you have described it elsewhere halts
>>> (in some finite number of steps it reaches a halt state - you haven't
>>> denied this, bearing in mind we're talking of the HP/Linz defined term
>>> "halts").
>>
>> int main()
>> {
>> H_Hat(H_Hat)
>>
>> invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>> which correctly decides that its first parameter would never halt unless
>> its execution is terminated.
>>
>> Everything else that you say is moot until you first understand the
>> details related to what I just said prove that what I just said is true.
>
> LOL, but they don't.
>
> You say that everything else I'm saying is moot, but that's just your
> way of avoiding having to take on board any reasoning that leads towards
> the conclusion that you're wrong. Similarly with your "unresponsive"
> answers to others' questions - you know, when you just change the
> subject and cut-and-paste stock phrases which you've repeated over and
> over, which in no way address the questions asked.
>
> It doesn't matter to me that you don't want to listen to people
> explaining your mistakes - cranks never do. My prediction when I made
> the previous post was that you would read half a dozen lines, then make
> some dismissive remark excusing you from thinking any further. This is
> your ages old pattern of behaviour, and as ever you are true to form. :)
>
> By all means ignore all feedback - just continue with your plan to
> publish your result and claim the recognition and credibility you feel
> you deserve. You've been trying for some years for this, and you feel
> it's coming, yet somehow it's never quite arrived! I'm happy for you
> that you feel the culmination of you life's work is nearly at hand, and
> you will finally get what's been coming to you for so long...
>
> Mike.
>
Unless and until you understand that this is a verifiable fact:
Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
correctly decides that its first parameter would never halt unless
its execution is terminated.
You will continue to falsely presume that any confusion about this is
mine and not yours.
That you tend to dismiss the details that prove that above statement is
true is a very strong indication of dishonestly on your part.
In any case an execution trace would prove the truth of this.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-01 21:32 +0000 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <54adnS4SpawctALCnZ2dnUU78eHNnZ2d@brightview.co.uk> |
| In reply to | #24797 |
On 01/11/2020 20:38, olcott wrote:
> On 11/1/2020 1:50 PM, Mike Terry wrote:
>> On 01/11/2020 18:18, olcott wrote:
>>> On 11/1/2020 10:11 AM, Mike Terry wrote:
>>>> On 01/11/2020 14:40, olcott wrote:
>>>>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>>>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>>>>
>>>>>>> It is apparently over your head that the above code specifies three
>>>>>>> different instances of H_Hat and that
>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly
>>>>>>> decide one of these three different instances.
>>>>>>
>>>>>> You seem to be unaware that H_Hat is a Turing machine, and as such
>>>>>> there
>>>>>> is but one definition of it.
>>>>>
>>>>> It can have one Turing Machine description that is executed multiple
>>>>> times by a master Turing machine. Each of these instances can have
>>>>> different amounts of data on their local tape.
>>>>>
>>>>> So it is exactly the same thing as three different instances of H_Hat
>>>>> each in their own local process context.
>>>>>
>>>>>> There is one embodiment of it as an actual machine in the probem, and
>>>>>> multiple copies of a representation of it, suitable for H to process.
>>>>>
>>>>> If we think of all of the machines involved as Turing Machine
>>>>> descriptions of UTMs that are executed by a single master UTM then we
>>>>> can get rid of the tedious dichotomy of a machine and its description
>>>>> and simply talk about machines that can execute other machines.
>>>>>
>>>>> In m y x86utm operting system the machine description language is x86
>>>>> and it is always directly executable.
>>>>>
>>>>>> For a given input, H_Hat will always produce the same result, that
>>>>>> is a
>>>>>> fundamental property of Turing Machines.
>>>>>
>>>>> Yet with three different instances of the same machine each one
>>>>> having a
>>>>> longer execution trace the outermost invocation has the data required
>>>>> to make its halting decision first. As soon as it terminates its
>>>>> subordinate the entire process chain stops running.
>>>>
>>>> The calculation H-Hat(H_Hat) as you have described it elsewhere halts
>>>> (in some finite number of steps it reaches a halt state - you haven't
>>>> denied this, bearing in mind we're talking of the HP/Linz defined term
>>>> "halts").
>>>
>>> int main()
>>> {
>>> H_Hat(H_Hat)
>>>
>>> invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>> which correctly decides that its first parameter would never halt unless
>>> its execution is terminated.
>>>
>>> Everything else that you say is moot until you first understand the
>>> details related to what I just said prove that what I just said is true.
>>
>> LOL, but they don't.
>>
>> You say that everything else I'm saying is moot, but that's just your
>> way of avoiding having to take on board any reasoning that leads
>> towards the conclusion that you're wrong. Similarly with your
>> "unresponsive" answers to others' questions - you know, when you just
>> change the subject and cut-and-paste stock phrases which you've
>> repeated over and over, which in no way address the questions asked.
>>
>> It doesn't matter to me that you don't want to listen to people
>> explaining your mistakes - cranks never do. My prediction when I made
>> the previous post was that you would read half a dozen lines, then
>> make some dismissive remark excusing you from thinking any further.
>> This is your ages old pattern of behaviour, and as ever you are true
>> to form. :)
>>
>> By all means ignore all feedback - just continue with your plan to
>> publish your result and claim the recognition and credibility you feel
>> you deserve. You've been trying for some years for this, and you feel
>> it's coming, yet somehow it's never quite arrived! I'm happy for you
>> that you feel the culmination of you life's work is nearly at hand,
>> and you will finally get what's been coming to you for so long...
>>
>> Mike.
>>
>
> Unless and until you understand that this is a verifiable fact:
>
> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
> correctly decides that its first parameter would never halt unless
> its execution is terminated.
>
> You will continue to falsely presume that any confusion about this is
> mine and not yours.
>
> That you tend to dismiss the details that prove that above statement is
> true is a very strong indication of dishonestly on your part.
>
> In any case an execution trace would prove the truth of this.
>
Although there's lots in you recent responses that I could comment on,
perhaps one way forward would be for you to explain how you expect a
trace to verify
"ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
parameter /would/ never halt /unless/ its execution is terminated"
?
Note the "correctly" - that implies you must have a definition of what
ABNHBD(P,I) /should/ be, in terms of P and I. Also note the conditional
/would/ - what does that mean, for a general input (P,I)?
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-01 15:54 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <UdWdnR2hyOYBswLCnZ2dnUU7-R_NnZ2d@giganews.com> |
| In reply to | #24798 |
On 11/1/2020 3:32 PM, Mike Terry wrote:
> On 01/11/2020 20:38, olcott wrote:
>> On 11/1/2020 1:50 PM, Mike Terry wrote:
>>> On 01/11/2020 18:18, olcott wrote:
>>>> On 11/1/2020 10:11 AM, Mike Terry wrote:
>>>>> On 01/11/2020 14:40, olcott wrote:
>>>>>> On 11/1/2020 7:19 AM, Richard Damon wrote:
>>>>>>> On 10/31/20 11:18 PM, olcott wrote:
>>>>>>>>
>>>>>>>> It is apparently over your head that the above code specifies three
>>>>>>>> different instances of H_Hat and that
>>>>>>>> Aborted_Because_Non_Halting_Behavior_Detected(P, P) does correctly
>>>>>>>> decide one of these three different instances.
>>>>>>>
>>>>>>> You seem to be unaware that H_Hat is a Turing machine, and as such
>>>>>>> there
>>>>>>> is but one definition of it.
>>>>>>
>>>>>> It can have one Turing Machine description that is executed multiple
>>>>>> times by a master Turing machine. Each of these instances can have
>>>>>> different amounts of data on their local tape.
>>>>>>
>>>>>> So it is exactly the same thing as three different instances of H_Hat
>>>>>> each in their own local process context.
>>>>>>
>>>>>>> There is one embodiment of it as an actual machine in the probem,
>>>>>>> and
>>>>>>> multiple copies of a representation of it, suitable for H to
>>>>>>> process.
>>>>>>
>>>>>> If we think of all of the machines involved as Turing Machine
>>>>>> descriptions of UTMs that are executed by a single master UTM then we
>>>>>> can get rid of the tedious dichotomy of a machine and its description
>>>>>> and simply talk about machines that can execute other machines.
>>>>>>
>>>>>> In m y x86utm operting system the machine description language is x86
>>>>>> and it is always directly executable.
>>>>>>
>>>>>>> For a given input, H_Hat will always produce the same result, that
>>>>>>> is a
>>>>>>> fundamental property of Turing Machines.
>>>>>>
>>>>>> Yet with three different instances of the same machine each one
>>>>>> having a
>>>>>> longer execution trace the outermost invocation has the data
>>>>>> required
>>>>>> to make its halting decision first. As soon as it terminates its
>>>>>> subordinate the entire process chain stops running.
>>>>>
>>>>> The calculation H-Hat(H_Hat) as you have described it elsewhere halts
>>>>> (in some finite number of steps it reaches a halt state - you haven't
>>>>> denied this, bearing in mind we're talking of the HP/Linz defined term
>>>>> "halts").
>>>>
>>>> int main()
>>>> {
>>>> H_Hat(H_Hat)
>>>>
>>>> invokes Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>>>> which correctly decides that its first parameter would never halt
>>>> unless
>>>> its execution is terminated.
>>>>
>>>> Everything else that you say is moot until you first understand the
>>>> details related to what I just said prove that what I just said is
>>>> true.
>>>
>>> LOL, but they don't.
>>>
>>> You say that everything else I'm saying is moot, but that's just your
>>> way of avoiding having to take on board any reasoning that leads
>>> towards the conclusion that you're wrong. Similarly with your
>>> "unresponsive" answers to others' questions - you know, when you just
>>> change the subject and cut-and-paste stock phrases which you've
>>> repeated over and over, which in no way address the questions asked.
>>>
>>> It doesn't matter to me that you don't want to listen to people
>>> explaining your mistakes - cranks never do. My prediction when I made
>>> the previous post was that you would read half a dozen lines, then
>>> make some dismissive remark excusing you from thinking any further.
>>> This is your ages old pattern of behaviour, and as ever you are true
>>> to form. :)
>>>
>>> By all means ignore all feedback - just continue with your plan to
>>> publish your result and claim the recognition and credibility you feel
>>> you deserve. You've been trying for some years for this, and you feel
>>> it's coming, yet somehow it's never quite arrived! I'm happy for you
>>> that you feel the culmination of you life's work is nearly at hand,
>>> and you will finally get what's been coming to you for so long...
>>>
>>> Mike.
>>>
>>
>> Unless and until you understand that this is a verifiable fact:
>>
>> Aborted_Because_Non_Halting_Behavior_Detected(H_Hat, H_Hat);
>> correctly decides that its first parameter would never halt unless
>> its execution is terminated.
>>
>> You will continue to falsely presume that any confusion about this is
>> mine and not yours.
>>
>> That you tend to dismiss the details that prove that above statement is
>> true is a very strong indication of dishonestly on your part.
>>
>> In any case an execution trace would prove the truth of this.
>>
>
> Although there's lots in you recent responses that I could comment on,
> perhaps one way forward would be for you to explain how you expect a
> trace to verify
>
> "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
> parameter /would/ never halt /unless/ its execution is terminated"
The sounds like an excellent way to proceed.
> Note the "correctly" - that implies you must have a definition of what
> ABNHBD(P,I) /should/ be, in terms of P and I.
First of all the name: ABNHBD(H_Hat, H_Hat)
is horribly terrible software engineering.
High quality software engineering always has the function name describe
exactly what the function does.
If the function does too many things that cannot be described in a
single concise name that proves** that the function needs to be
decomposed into smaller functions. ** (for good software engineering).
When this function:
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
operates correctly then it
"Aborted its input Because Non-Halting Behavior was Detected".
It is utterly ridiculous that you have had such a very difficult time
with that part. Perhaps you have lots and lots of experience with naming
your functions like this: ABNHBD() and it never occurred to you that the
best function names precisely describe exactly what the function does.
> Also note the conditional
> /would/ - what does that mean, for a general input (P,I)?
>
> Mike.
I am answering specifically rather than generally.
When we comment out the part of
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
that aborts its input when it detects non-halting behavior and run:
int main()
{
H_Hat(H_Hat);
the execution of H_Hat never terminates.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-02 00:46 +0000 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <87h7q8vb4w.fsf@bsb.me.uk> |
| In reply to | #24799 |
olcott <NoOne@NoWhere.com> writes: > On 11/1/2020 3:32 PM, Mike Terry wrote: >> Although there's lots in you recent responses that I could comment >> on, perhaps one way forward would be for you to explain how you >> expect a trace to verify >> >> "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first >> parameter /would/ never halt /unless/ its execution is terminated" > > The sounds like an excellent way to proceed. > >> Note the "correctly" - that implies you must have a definition of >> what ABNHBD(P,I) /should/ be, in terms of P and I. <cut> > When this function: > bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I); > > operates correctly then it > "Aborted its input Because Non-Halting Behavior was Detected". > > It is utterly ridiculous that you have had such a very difficult time > with that part. Perhaps you have lots and lots of experience with > naming your functions like this: ABNHBD() and it never occurred to you > that the best function names precisely describe exactly what the > function does. Never returning either true or false is consistent with this function's name. Returning false for a non-halting computation what was not detected to be non-halting is consistent with this function's name. Other instances where the name is vague are also arguable, but less obviously so. Maybe you meant to call it True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise Probably not, because you must be trying to sneak some incorrect decisions past your readers by using your bad name. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-01 19:05 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <P_adnYPBAaWixgLCnZ2dnUU7-R_NnZ2d@giganews.com> |
| In reply to | #24806 |
On 11/1/2020 6:46 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 11/1/2020 3:32 PM, Mike Terry wrote: >>> Although there's lots in you recent responses that I could comment >>> on, perhaps one way forward would be for you to explain how you >>> expect a trace to verify >>> >>> "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first >>> parameter /would/ never halt /unless/ its execution is terminated" >> >> The sounds like an excellent way to proceed. >> >>> Note the "correctly" - that implies you must have a definition of >>> what ABNHBD(P,I) /should/ be, in terms of P and I. > <cut> >> When this function: >> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I); >> >> operates correctly then it >> "Aborted its input Because Non-Halting Behavior was Detected". >> >> It is utterly ridiculous that you have had such a very difficult time >> with that part. Perhaps you have lots and lots of experience with >> naming your functions like this: ABNHBD() and it never occurred to you >> that the best function names precisely describe exactly what the >> function does. > > Never returning either true or false is consistent with this function's > name. > > Returning false for a non-halting computation what was not detected to be > non-halting is consistent with this function's name. > > Other instances where the name is vague are also arguable, but less > obviously so. > > Maybe you meant to call it > > True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise > > Probably not, because you must be trying to sneak some incorrect > decisions past your readers by using your bad name. > If your suggestion would work (and it might) then we could go all the way back to simply: Not_Halts(P, I) which is understood to mean: Stops executing and Accepts any and all non-halting inputs and Rejects any and all halting inputs as soon as they halt. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-01 19:10 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <m-idnfWSPM0_wQLCnZ2dnUU7-fvNnZ2d@giganews.com> |
| In reply to | #24807 |
On 11/1/2020 7:05 PM, olcott wrote: > On 11/1/2020 6:46 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 11/1/2020 3:32 PM, Mike Terry wrote: >>>> Although there's lots in you recent responses that I could comment >>>> on, perhaps one way forward would be for you to explain how you >>>> expect a trace to verify >>>> >>>> "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first >>>> parameter /would/ never halt /unless/ its execution is terminated" >>> >>> The sounds like an excellent way to proceed. >>> >>>> Note the "correctly" - that implies you must have a definition of >>>> what ABNHBD(P,I) /should/ be, in terms of P and I. >> <cut> >>> When this function: >>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I); >>> >>> operates correctly then it >>> "Aborted its input Because Non-Halting Behavior was Detected". >>> >>> It is utterly ridiculous that you have had such a very difficult time >>> with that part. Perhaps you have lots and lots of experience with >>> naming your functions like this: ABNHBD() and it never occurred to you >>> that the best function names precisely describe exactly what the >>> function does. >> >> Never returning either true or false is consistent with this function's >> name. >> >> Returning false for a non-halting computation what was not detected to be >> non-halting is consistent with this function's name. >> >> Other instances where the name is vague are also arguable, but less >> obviously so. >> >> Maybe you meant to call it >> >> >> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise >> >> Probably not, because you must be trying to sneak some incorrect >> decisions past your readers by using your bad name. >> > > If your suggestion would work (and it might) then we could go all the > way back to simply: Not_Halts(P, I) which is understood to mean: > > Stops executing and Accepts any and all non-halting inputs and Rejects > any and all halting inputs as soon as they halt. So as I have already said very many times in very many ways if we define the halt decider as a non-halting decider that only makes its non-halting decision after the execution of its input is terminated ... then the halting problem trick of defining an input that "Does the opposite of whatever the halt decider decides" has been utterly defeated and the halting problem is no longer proven to be undecidable. -- Copyright 2020 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 | 2020-11-01 21:57 -0500 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <wAKnH.346145$RY8.267188@fx48.iad> |
| In reply to | #24808 |
On 11/1/20 8:10 PM, olcott wrote: > > So as I have already said very many times in very many ways if we define > the halt decider as a non-halting decider that only makes its > non-halting decision after the execution of its input is terminated ... > > then the halting problem trick of defining an input that > "Does the opposite of whatever the halt decider decides" > > has been utterly defeated and the halting problem is no longer proven to > be undecidable. If you are not answering the original Halting Problem question, then your answer is meaningless in saying anytning about the Halting Problem The Halting problem is also focused on the Turing Machine that is represented by the input, so what happens to the input isn't important. Your machine FAILS, as its answer does not match the results of that actual machine. In fact, if we do your experiment and remove the halt detection code from the H in H_Hat2 or the top level H, but do not change the input tape (so that H inside H_Hat2 still had the halt detection code), then for H_Hat2, the answers are correct, the top level machine does report that H_Hat2 halts. Thus we can show that issue isn't that H_Hat2 has non-halting behavior, but that the non-halting detection code instills a bug in your H. (Note, this is effectively saying we are running H_Hat2'(H_Hat2) and H(H_Hat2', H_Hat2) This doesn't fix H_Hat, but it does change the answer H gives to Halting, and the behavior of H_Hat to non-Halting.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-01 22:33 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <IIydnZiKlde1EQLCnZ2dnUU7-fdQAAAA@giganews.com> |
| In reply to | #24814 |
On 11/1/2020 8:57 PM, Richard Damon wrote:
> On 11/1/20 8:10 PM, olcott wrote:
>>
>> So as I have already said very many times in very many ways if we define
>> the halt decider as a non-halting decider that only makes its
>> non-halting decision after the execution of its input is terminated ...
>>
>> then the halting problem trick of defining an input that
>> "Does the opposite of whatever the halt decider decides"
>>
>> has been utterly defeated and the halting problem is no longer proven to
>> be undecidable.
>
> If you are not answering the original Halting Problem question, then
> your answer is meaningless in saying anytning about the Halting Problem
>
> The Halting problem is also focused on the Turing Machine that is
> represented by the input, so what happens to the input isn't important.
>
> Your machine FAILS, as its answer does not match the results of that
> actual machine.
>
> In fact, if we do your experiment and remove the halt detection code
> from the H in H_Hat2 or the top level H, but do not change the input
> tape (so that H inside H_Hat2 still had the halt detection code), then
> for H_Hat2, the answers are correct, the top level machine does report
> that H_Hat2 halts. Thus we can show that issue isn't that H_Hat2 has
> non-halting behavior, but that the non-halting detection code instills a
> bug in your H.
>
> (Note, this is effectively saying we are running H_Hat2'(H_Hat2) and
> H(H_Hat2', H_Hat2)
>
> This doesn't fix H_Hat, but it does change the answer H gives to
> Halting, and the behavior of H_Hat to non-Halting.
>
void Halts_Fooler(u32 P)
{
if (Halts(P, P))
HERE: goto HERE;
else
HALT
}
bool Halts(u32 P, u32 I)
{
if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
return false // Non halting behavior detected
else
return true; // Input has already halted
}
When the halt decider does not makes its halting decision until after
the input program has stopped running then the conventional halting
problem trick: "Do the opposite of whatever the halt decider decides"
cannot possibly make halting undecidable.
--
Copyright 2020 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 | 2020-11-02 08:53 -0500 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <4bUnH.380432$575.53569@fx38.iad> |
| In reply to | #24825 |
On 11/1/20 11:33 PM, olcott wrote:
> On 11/1/2020 8:57 PM, Richard Damon wrote:
>> On 11/1/20 8:10 PM, olcott wrote:
>>>
>>> So as I have already said very many times in very many ways if we define
>>> the halt decider as a non-halting decider that only makes its
>>> non-halting decision after the execution of its input is terminated ...
>>>
>>> then the halting problem trick of defining an input that
>>> "Does the opposite of whatever the halt decider decides"
>>>
>>> has been utterly defeated and the halting problem is no longer proven to
>>> be undecidable.
>>
>> If you are not answering the original Halting Problem question, then
>> your answer is meaningless in saying anytning about the Halting Problem
>>
>> The Halting problem is also focused on the Turing Machine that is
>> represented by the input, so what happens to the input isn't important.
>>
>> Your machine FAILS, as its answer does not match the results of that
>> actual machine.
>>
>> In fact, if we do your experiment and remove the halt detection code
>> from the H in H_Hat2 or the top level H, but do not change the input
>> tape (so that H inside H_Hat2 still had the halt detection code), then
>> for H_Hat2, the answers are correct, the top level machine does report
>> that H_Hat2 halts. Thus we can show that issue isn't that H_Hat2 has
>> non-halting behavior, but that the non-halting detection code instills a
>> bug in your H.
>>
>> (Note, this is effectively saying we are running H_Hat2'(H_Hat2) and
>> H(H_Hat2', H_Hat2)
>>
>> This doesn't fix H_Hat, but it does change the answer H gives to
>> Halting, and the behavior of H_Hat to non-Halting.
>>
>
> void Halts_Fooler(u32 P)
> {
> if (Halts(P, P))
> HERE: goto HERE;
> else
> HALT
> }
>
>
> bool Halts(u32 P, u32 I)
> {
> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
> return false // Non halting behavior detected
> else
> return true; // Input has already halted
> }
>
> When the halt decider does not makes its halting decision until after
> the input program has stopped running then the conventional halting
> problem trick: "Do the opposite of whatever the halt decider decides"
> cannot possibly make halting undecidable.
>
>
Just stating it is not a Proof!!!!!!
Yes, your halt decider has aborted the emulation of the input program,
but it has NOT proven that this aborting is due to surely unlimited
execution.
Let us for example define a function Halts_Tricker as
void Halts_Tricker(u32 P)
{
if (Halts(P, P))
HALT
else
HALT
}
This function clearly halts if Halts(P, P) returns, and if Halts(P, P)
fails to return then is has failed to be an suitable Halting decider.
Your description of Halts will get this problem wrong.
In fact, lets go one simpler, let us define a very simple machine Halter as
void Halter()
{
HALT
}
and let us ask if H will be able to detect this so we run H(H, Halter)
and you system will (as I understand it) report Aborted, thus showing
that your H fails to meet the requirements of Halting behavior. So by
YOUR definition of halting behavior, your H doesn't meet the requirement.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-02 08:04 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <WcOdnfc0jd1IjD3CnZ2dnUU7-cWdnZ2d@giganews.com> |
| In reply to | #24829 |
On 11/2/2020 7:53 AM, Richard Damon wrote:
> On 11/1/20 11:33 PM, olcott wrote:
>> On 11/1/2020 8:57 PM, Richard Damon wrote:
>>> On 11/1/20 8:10 PM, olcott wrote:
>>>>
>>>> So as I have already said very many times in very many ways if we define
>>>> the halt decider as a non-halting decider that only makes its
>>>> non-halting decision after the execution of its input is terminated ...
>>>>
>>>> then the halting problem trick of defining an input that
>>>> "Does the opposite of whatever the halt decider decides"
>>>>
>>>> has been utterly defeated and the halting problem is no longer proven to
>>>> be undecidable.
>>>
>>> If you are not answering the original Halting Problem question, then
>>> your answer is meaningless in saying anytning about the Halting Problem
>>>
>>> The Halting problem is also focused on the Turing Machine that is
>>> represented by the input, so what happens to the input isn't important.
>>>
>>> Your machine FAILS, as its answer does not match the results of that
>>> actual machine.
>>>
>>> In fact, if we do your experiment and remove the halt detection code
>>> from the H in H_Hat2 or the top level H, but do not change the input
>>> tape (so that H inside H_Hat2 still had the halt detection code), then
>>> for H_Hat2, the answers are correct, the top level machine does report
>>> that H_Hat2 halts. Thus we can show that issue isn't that H_Hat2 has
>>> non-halting behavior, but that the non-halting detection code instills a
>>> bug in your H.
>>>
>>> (Note, this is effectively saying we are running H_Hat2'(H_Hat2) and
>>> H(H_Hat2', H_Hat2)
>>>
>>> This doesn't fix H_Hat, but it does change the answer H gives to
>>> Halting, and the behavior of H_Hat to non-Halting.
>>>
>>
>> void Halts_Fooler(u32 P)
>> {
>> if (Halts(P, P))
>> HERE: goto HERE;
>> else
>> HALT
>> }
>>
>>
>> bool Halts(u32 P, u32 I)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>> return false // Non halting behavior detected
>> else
>> return true; // Input has already halted
>> }
>>
>> When the halt decider does not makes its halting decision until after
>> the input program has stopped running then the conventional halting
>> problem trick: "Do the opposite of whatever the halt decider decides"
>> cannot possibly make halting undecidable.
>>
>>
>
> Just stating it is not a Proof!!!!!!
>
> Yes, your halt decider has aborted the emulation of the input program,
> but it has NOT proven that this aborting is due to surely unlimited
> execution.
>
> Let us for example define a function Halts_Tricker as
>
> void Halts_Tricker(u32 P)
> {
> if (Halts(P, P))
> HALT
> else
> HALT
> }
>
> This function clearly halts if Halts(P, P) returns, and if Halts(P, P)
> fails to return then is has failed to be an suitable Halting decider.
>
> Your description of Halts will get this problem wrong.
>
>
> In fact, lets go one simpler, let us define a very simple machine Halter as
>
> void Halter()
> {
> HALT
> }
>
> and let us ask if H will be able to detect this so we run H(H, Halter)
> and you system will (as I understand it) report Aborted, thus showing
> that your H fails to meet the requirements of Halting behavior. So by
> YOUR definition of halting behavior, your H doesn't meet the requirement.
>
void Halts_Fooler(u32 P)
{
if (Halts(P, P))
HERE: goto HERE;
else
HALT
}
bool Halts(u32 P, u32 I)
{
if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
return false // Non halting behavior detected
else
return true; // Input has already halted
}
When the halt decider does not make its halting decision until after the
input program has stopped running then the conventional halting problem
trick: "Do the opposite of whatever the halt decider decides"
cannot possibly make halting undecidable.
--
Copyright 2020 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 | 2020-11-02 10:45 -0500 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <mQVnH.786250$AN2.100238@fx46.iad> |
| In reply to | #24832 |
On 11/2/20 9:04 AM, olcott wrote:
> On 11/2/2020 7:53 AM, Richard Damon wrote:
>> On 11/1/20 11:33 PM, olcott wrote:
>>> On 11/1/2020 8:57 PM, Richard Damon wrote:
>>>> On 11/1/20 8:10 PM, olcott wrote:
>>>>>
>>>>> So as I have already said very many times in very many ways if we
>>>>> define
>>>>> the halt decider as a non-halting decider that only makes its
>>>>> non-halting decision after the execution of its input is terminated
>>>>> ...
>>>>>
>>>>> then the halting problem trick of defining an input that
>>>>> "Does the opposite of whatever the halt decider decides"
>>>>>
>>>>> has been utterly defeated and the halting problem is no longer
>>>>> proven to
>>>>> be undecidable.
>>>>
>>>> If you are not answering the original Halting Problem question, then
>>>> your answer is meaningless in saying anytning about the Halting Problem
>>>>
>>>> The Halting problem is also focused on the Turing Machine that is
>>>> represented by the input, so what happens to the input isn't important.
>>>>
>>>> Your machine FAILS, as its answer does not match the results of that
>>>> actual machine.
>>>>
>>>> In fact, if we do your experiment and remove the halt detection code
>>>> from the H in H_Hat2 or the top level H, but do not change the input
>>>> tape (so that H inside H_Hat2 still had the halt detection code), then
>>>> for H_Hat2, the answers are correct, the top level machine does report
>>>> that H_Hat2 halts. Thus we can show that issue isn't that H_Hat2 has
>>>> non-halting behavior, but that the non-halting detection code
>>>> instills a
>>>> bug in your H.
>>>>
>>>> (Note, this is effectively saying we are running H_Hat2'(H_Hat2) and
>>>> H(H_Hat2', H_Hat2)
>>>>
>>>> This doesn't fix H_Hat, but it does change the answer H gives to
>>>> Halting, and the behavior of H_Hat to non-Halting.
>>>>
>>>
>>> void Halts_Fooler(u32 P)
>>> {
>>> if (Halts(P, P))
>>> HERE: goto HERE;
>>> else
>>> HALT
>>> }
>>>
>>>
>>> bool Halts(u32 P, u32 I)
>>> {
>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>>> return false // Non halting behavior detected
>>> else
>>> return true; // Input has already halted
>>> }
>>>
>>> When the halt decider does not makes its halting decision until after
>>> the input program has stopped running then the conventional halting
>>> problem trick: "Do the opposite of whatever the halt decider decides"
>>> cannot possibly make halting undecidable.
>>>
>>>
>>
>> Just stating it is not a Proof!!!!!!
>>
>> Yes, your halt decider has aborted the emulation of the input program,
>> but it has NOT proven that this aborting is due to surely unlimited
>> execution.
>>
>> Let us for example define a function Halts_Tricker as
>>
>> void Halts_Tricker(u32 P)
>> {
>> if (Halts(P, P))
>> HALT
>> else
>> HALT
>> }
>>
>> This function clearly halts if Halts(P, P) returns, and if Halts(P, P)
>> fails to return then is has failed to be an suitable Halting decider.
>>
>> Your description of Halts will get this problem wrong.
>>
>>
>> In fact, lets go one simpler, let us define a very simple machine
>> Halter as
>>
>> void Halter()
>> {
>> HALT
>> }
>>
>> and let us ask if H will be able to detect this so we run H(H, Halter)
>> and you system will (as I understand it) report Aborted, thus showing
>> that your H fails to meet the requirements of Halting behavior. So by
>> YOUR definition of halting behavior, your H doesn't meet the requirement.
>>
>
> void Halts_Fooler(u32 P)
> {
> if (Halts(P, P))
> HERE: goto HERE;
> else
> HALT
> }
>
> bool Halts(u32 P, u32 I)
> {
> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
> return false // Non halting behavior detected
> else
> return true; // Input has already halted
> }
>
> When the halt decider does not make its halting decision until after the
> input program has stopped running then the conventional halting problem
> trick: "Do the opposite of whatever the halt decider decides"
> cannot possibly make halting undecidable.
>
>
You write code, but you don't say what answer it give, or why?
In particular, what would be the trace and answer of
H(H, Halts_Tricker)
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-02 03:00 +0000 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <87sg9stqcf.fsf@bsb.me.uk> |
| In reply to | #24808 |
olcott <NoOne@NoWhere.com> writes:
> On 11/1/2020 7:05 PM, olcott wrote:
>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>> Although there's lots in you recent responses that I could comment
>>>>> on, perhaps one way forward would be for you to explain how you
>>>>> expect a trace to verify
>>>>>
>>>>> "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>> parameter /would/ never halt /unless/ its execution is terminated"
>>>>
>>>> The sounds like an excellent way to proceed.
>>>>
>>>>> Note the "correctly" - that implies you must have a definition of
>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>> <cut>
>>>> When this function:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>
>>>> operates correctly then it
>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>
>>>> It is utterly ridiculous that you have had such a very difficult time
>>>> with that part. Perhaps you have lots and lots of experience with
>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>> that the best function names precisely describe exactly what the
>>>> function does.
>>>
>>> Never returning either true or false is consistent with this function's
>>> name.
>>>
>>> Returning false for a non-halting computation what was not detected to be
>>> non-halting is consistent with this function's name.
>>>
>>> Other instances where the name is vague are also arguable, but less
>>> obviously so.
>>>
>>> Maybe you meant to call it
>>>
>>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>>
>>> Probably not, because you must be trying to sneak some incorrect
>>> decisions past your readers by using your bad name.
>>>
>>
>> If your suggestion would work (and it might) then we could go all the
>> way back to simply: Not_Halts(P, I) which is understood to mean:
>>
>> Stops executing and Accepts any and all non-halting inputs and
>> Rejects any and all halting inputs as soon as they halt.
>
> So as I have already said very many times in very many ways if we
> define the halt decider as a non-halting decider that only makes its
> non-halting decision after the execution of its input is terminated
> ...
>
> then the halting problem trick of defining an input that
> "Does the opposite of whatever the halt decider decides"
>
> has been utterly defeated and the halting problem is no longer proven
> to be undecidable.
This is a separate bit of nonsense, unconnected to the vague name you
gave your function. Whether p(i) is or is not a halting computation is
independent of when (or even if) it is run.
A function that looks like this:
void huh?(i)
{
if True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(i, i)
then skip
else while true do skip od
}
will, were it to exist, be a problem for this function call:
True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
if that function has to live up to it's long name. This problem is
unrelated to how the long-named function does it's work. It need not
emulate the computation huh?(huh?) at all, but if it does, it can't
emulate the computation exactly, because that exact emulation may not
terminate. But however it decides that it either can't or shouldn't or
needn't continue with the emulation the basic logic is unchanged. If
True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
is true, huh?(huh?) is a halting computation, and if
True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
is false, huh?(huh?) is a non-halting computation.
Just for the hell of it I'm going to show you the key part of an
argument that does not rely on assuming a non-existent function.
Instead the conclusion of reached by reasoning about the properties of a
particular expression in the language.
Consider the higher-order function
void p(d, i)
{
if d(i, i)
then skip
else while true do skip od
}
with a function argument such that the partial application p(f) is the
one-argument function that uses some function f to decide whether to halt
or not. Now consider the expression f(p(f), p(f)). This is the
condition that is tested in the 'if' of the computation p(f, p(f)).
No matter what the function f is, if the expression f(p(f), p(f)) is
either true, false or it has no value because it is itself a non-halting
computation.
If f(p(f), p(f)) is true, then the computation p(f, p(f)) is a halting
one, and if f(p(f), p(f)) is false or has no value due to being itself a
non-halting computation, then p(f, p(f)) is a non-halting computation.
In other words, if the language is expressive enough to write the
function p, it can't be used to write a non-halting decider.
(Obviously a similar argument shows that no function written in this
language can be a halt decider, but you flipped over to considering
non-halting deciders, so I did as well.)
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-01 22:32 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <IIydnZmKlddrFgLCnZ2dnUU7-ffNnZ2d@giganews.com> |
| In reply to | #24815 |
On 11/1/2020 9:00 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/1/2020 7:05 PM, olcott wrote:
>>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>>> Although there's lots in you recent responses that I could comment
>>>>>> on, perhaps one way forward would be for you to explain how you
>>>>>> expect a trace to verify
>>>>>>
>>>>>> "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>>> parameter /would/ never halt /unless/ its execution is terminated"
>>>>>
>>>>> The sounds like an excellent way to proceed.
>>>>>
>>>>>> Note the "correctly" - that implies you must have a definition of
>>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>>> <cut>
>>>>> When this function:
>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>>
>>>>> operates correctly then it
>>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>>
>>>>> It is utterly ridiculous that you have had such a very difficult time
>>>>> with that part. Perhaps you have lots and lots of experience with
>>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>>> that the best function names precisely describe exactly what the
>>>>> function does.
>>>>
>>>> Never returning either true or false is consistent with this function's
>>>> name.
>>>>
>>>> Returning false for a non-halting computation what was not detected to be
>>>> non-halting is consistent with this function's name.
>>>>
>>>> Other instances where the name is vague are also arguable, but less
>>>> obviously so.
>>>>
>>>> Maybe you meant to call it
>>>>
>>>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>>>
>>>> Probably not, because you must be trying to sneak some incorrect
>>>> decisions past your readers by using your bad name.
>>>>
>>>
>>> If your suggestion would work (and it might) then we could go all the
>>> way back to simply: Not_Halts(P, I) which is understood to mean:
>>>
>>> Stops executing and Accepts any and all non-halting inputs and
>>> Rejects any and all halting inputs as soon as they halt.
>>
>> So as I have already said very many times in very many ways if we
>> define the halt decider as a non-halting decider that only makes its
>> non-halting decision after the execution of its input is terminated
>> ...
>>
>> then the halting problem trick of defining an input that
>> "Does the opposite of whatever the halt decider decides"
>>
>> has been utterly defeated and the halting problem is no longer proven
>> to be undecidable.
>
> This is a separate bit of nonsense, unconnected to the vague name you
> gave your function. Whether p(i) is or is not a halting computation is
> independent of when (or even if) it is run.
>
> A function that looks like this:
>
> void huh?(i)
> {
> if True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(i, i)
> then skip
> else while true do skip od
> }
>
> will, were it to exist, be a problem for this function call:
>
> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>
> if that function has to live up to it's long name. This problem is
> unrelated to how the long-named function does it's work. It need not
> emulate the computation huh?(huh?) at all, but if it does, it can't
> emulate the computation exactly, because that exact emulation may not
> terminate. But however it decides that it either can't or shouldn't or
> needn't continue with the emulation the basic logic is unchanged. If
>
> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>
> is true, huh?(huh?) is a halting computation, and if
>
> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>
> is false, huh?(huh?) is a non-halting computation.
>
>
> Just for the hell of it I'm going to show you the key part of an
> argument that does not rely on assuming a non-existent function.
> Instead the conclusion of reached by reasoning about the properties of a
> particular expression in the language.
>
> Consider the higher-order function
>
> void p(d, i)
> {
> if d(i, i)
> then skip
> else while true do skip od
> }
>
> with a function argument such that the partial application p(f) is the
> one-argument function that uses some function f to decide whether to halt
> or not. Now consider the expression f(p(f), p(f)). This is the
> condition that is tested in the 'if' of the computation p(f, p(f)).
>
> No matter what the function f is, if the expression f(p(f), p(f)) is
> either true, false or it has no value because it is itself a non-halting
> computation.
>
> If f(p(f), p(f)) is true, then the computation p(f, p(f)) is a halting
> one, and if f(p(f), p(f)) is false or has no value due to being itself a
> non-halting computation, then p(f, p(f)) is a non-halting computation.
>
> In other words, if the language is expressive enough to write the
> function p, it can't be used to write a non-halting decider.
>
> (Obviously a similar argument shows that no function written in this
> language can be a halt decider, but you flipped over to considering
> non-halting deciders, so I did as well.)
>
void Halts_Fooler(u32 P)
{
if (Halts(P, P))
HERE: goto HERE;
else
HALT
}
bool Halts(u32 P, u32 I)
{
if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
return false // Non halting behavior detected
else
return true; // Input has already halted
}
When the halt decider does not makes its halting decision until after
the input program has stopped running then the conventional halting
problem trick: "Do the opposite of whatever the halt decider decides"
cannot possibly make halting undecidable.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-02 20:55 +0000 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <87o8kfsckg.fsf@bsb.me.uk> |
| In reply to | #24824 |
olcott <NoOne@NoWhere.com> writes:
> On 11/1/2020 9:00 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/1/2020 7:05 PM, olcott wrote:
>>>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>>>> Although there's lots in you recent responses that I could comment
>>>>>>> on, perhaps one way forward would be for you to explain how you
>>>>>>> expect a trace to verify
>>>>>>>
>>>>>>> "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>>>> parameter /would/ never halt /unless/ its execution is terminated"
>>>>>>
>>>>>> The sounds like an excellent way to proceed.
>>>>>>
>>>>>>> Note the "correctly" - that implies you must have a definition of
>>>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>>>> <cut>
>>>>>> When this function:
>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>>>
>>>>>> operates correctly then it
>>>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>>>
>>>>>> It is utterly ridiculous that you have had such a very difficult time
>>>>>> with that part. Perhaps you have lots and lots of experience with
>>>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>>>> that the best function names precisely describe exactly what the
>>>>>> function does.
>>>>>
>>>>> Never returning either true or false is consistent with this function's
>>>>> name.
>>>>>
>>>>> Returning false for a non-halting computation what was not detected to be
>>>>> non-halting is consistent with this function's name.
>>>>>
>>>>> Other instances where the name is vague are also arguable, but less
>>>>> obviously so.
>>>>>
>>>>> Maybe you meant to call it
>>>>>
>>>>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>>>>
>>>>> Probably not, because you must be trying to sneak some incorrect
>>>>> decisions past your readers by using your bad name.
>>>>>
>>>>
>>>> If your suggestion would work (and it might) then we could go all the
>>>> way back to simply: Not_Halts(P, I) which is understood to mean:
>>>>
>>>> Stops executing and Accepts any and all non-halting inputs and
>>>> Rejects any and all halting inputs as soon as they halt.
>>>
>>> So as I have already said very many times in very many ways if we
>>> define the halt decider as a non-halting decider that only makes its
>>> non-halting decision after the execution of its input is terminated
>>> ...
>>>
>>> then the halting problem trick of defining an input that
>>> "Does the opposite of whatever the halt decider decides"
>>>
>>> has been utterly defeated and the halting problem is no longer proven
>>> to be undecidable.
>>
>> This is a separate bit of nonsense, unconnected to the vague name you
>> gave your function. Whether p(i) is or is not a halting computation is
>> independent of when (or even if) it is run.
>>
>> A function that looks like this:
>>
>> void huh?(i)
>> {
>> if True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(i, i)
>> then skip
>> else while true do skip od
>> }
>>
>> will, were it to exist, be a problem for this function call:
>>
>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>>
>> if that function has to live up to it's long name. This problem is
>> unrelated to how the long-named function does it's work. It need not
>> emulate the computation huh?(huh?) at all, but if it does, it can't
>> emulate the computation exactly, because that exact emulation may not
>> terminate. But however it decides that it either can't or shouldn't or
>> needn't continue with the emulation the basic logic is unchanged. If
>>
>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>>
>> is true, huh?(huh?) is a halting computation, and if
>>
>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>>
>> is false, huh?(huh?) is a non-halting computation.
>>
>>
>> Just for the hell of it I'm going to show you the key part of an
>> argument that does not rely on assuming a non-existent function.
>> Instead the conclusion of reached by reasoning about the properties of a
>> particular expression in the language.
>>
>> Consider the higher-order function
>>
>> void p(d, i)
>> {
>> if d(i, i)
>> then skip
>> else while true do skip od
>> }
>>
>> with a function argument such that the partial application p(f) is the
>> one-argument function that uses some function f to decide whether to halt
>> or not. Now consider the expression f(p(f), p(f)). This is the
>> condition that is tested in the 'if' of the computation p(f, p(f)).
>>
>> No matter what the function f is, if the expression f(p(f), p(f)) is
>> either true, false or it has no value because it is itself a non-halting
>> computation.
>>
>> If f(p(f), p(f)) is true, then the computation p(f, p(f)) is a halting
>> one, and if f(p(f), p(f)) is false or has no value due to being itself a
>> non-halting computation, then p(f, p(f)) is a non-halting computation.
>>
>> In other words, if the language is expressive enough to write the
>> function p, it can't be used to write a non-halting decider.
>>
>> (Obviously a similar argument shows that no function written in this
>> language can be a halt decider, but you flipped over to considering
>> non-halting deciders, so I did as well.)
>>
>
>
> void Halts_Fooler(u32 P)
> {
> if (Halts(P, P))
> HERE: goto HERE;
> else
> HALT
> }
>
>
> bool Halts(u32 P, u32 I)
> {
> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
> return false // Non halting behavior detected
> else
> return true; // Input has already halted
> }
>
> When the halt decider does not makes its halting decision until after
> the input program has stopped running then the conventional halting
> problem trick: "Do the opposite of whatever the halt decider decides"
> cannot possibly make halting undecidable.
This fails for the reasons that I and other have pointed out. You
appear now to be in output only mode. Not only that, it's cut and paste
output.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-02 15:20 -0600 |
| Subject | Re: Architectural design of a halting problem solution [ Bill the auto mechanic can fix your car ] |
| Message-ID | <AeCdnZWWlIuq5T3CnZ2dnUU7-UfNnZ2d@giganews.com> |
| In reply to | #24845 |
On 11/2/2020 2:55 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/1/2020 9:00 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/1/2020 7:05 PM, olcott wrote:
>>>>> On 11/1/2020 6:46 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 11/1/2020 3:32 PM, Mike Terry wrote:
>>>>>>>> Although there's lots in you recent responses that I could comment
>>>>>>>> on, perhaps one way forward would be for you to explain how you
>>>>>>>> expect a trace to verify
>>>>>>>>
>>>>>>>> "ABNHBD(H_Hat, H_Hat) /correctly/ decides that its first
>>>>>>>> parameter /would/ never halt /unless/ its execution is terminated"
>>>>>>>
>>>>>>> The sounds like an excellent way to proceed.
>>>>>>>
>>>>>>>> Note the "correctly" - that implies you must have a definition of
>>>>>>>> what ABNHBD(P,I) /should/ be, in terms of P and I.
>>>>>> <cut>
>>>>>>> When this function:
>>>>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>>>>>>>
>>>>>>> operates correctly then it
>>>>>>> "Aborted its input Because Non-Halting Behavior was Detected".
>>>>>>>
>>>>>>> It is utterly ridiculous that you have had such a very difficult time
>>>>>>> with that part. Perhaps you have lots and lots of experience with
>>>>>>> naming your functions like this: ABNHBD() and it never occurred to you
>>>>>>> that the best function names precisely describe exactly what the
>>>>>>> function does.
>>>>>>
>>>>>> Never returning either true or false is consistent with this function's
>>>>>> name.
>>>>>>
>>>>>> Returning false for a non-halting computation what was not detected to be
>>>>>> non-halting is consistent with this function's name.
>>>>>>
>>>>>> Other instances where the name is vague are also arguable, but less
>>>>>> obviously so.
>>>>>>
>>>>>> Maybe you meant to call it
>>>>>>
>>>>>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise
>>>>>>
>>>>>> Probably not, because you must be trying to sneak some incorrect
>>>>>> decisions past your readers by using your bad name.
>>>>>>
>>>>>
>>>>> If your suggestion would work (and it might) then we could go all the
>>>>> way back to simply: Not_Halts(P, I) which is understood to mean:
>>>>>
>>>>> Stops executing and Accepts any and all non-halting inputs and
>>>>> Rejects any and all halting inputs as soon as they halt.
>>>>
>>>> So as I have already said very many times in very many ways if we
>>>> define the halt decider as a non-halting decider that only makes its
>>>> non-halting decision after the execution of its input is terminated
>>>> ...
>>>>
>>>> then the halting problem trick of defining an input that
>>>> "Does the opposite of whatever the halt decider decides"
>>>>
>>>> has been utterly defeated and the halting problem is no longer proven
>>>> to be undecidable.
>>>
>>> This is a separate bit of nonsense, unconnected to the vague name you
>>> gave your function. Whether p(i) is or is not a halting computation is
>>> independent of when (or even if) it is run.
>>>
>>> A function that looks like this:
>>>
>>> void huh?(i)
>>> {
>>> if True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(i, i)
>>> then skip
>>> else while true do skip od
>>> }
>>>
>>> will, were it to exist, be a problem for this function call:
>>>
>>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>>>
>>> if that function has to live up to it's long name. This problem is
>>> unrelated to how the long-named function does it's work. It need not
>>> emulate the computation huh?(huh?) at all, but if it does, it can't
>>> emulate the computation exactly, because that exact emulation may not
>>> terminate. But however it decides that it either can't or shouldn't or
>>> needn't continue with the emulation the basic logic is unchanged. If
>>>
>>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>>>
>>> is true, huh?(huh?) is a halting computation, and if
>>>
>>> True_If_And_Only_If_P(I)_Is_A_Non_Halting_Computation_And_False_Otherwise(huh?, huh?)
>>>
>>> is false, huh?(huh?) is a non-halting computation.
>>>
>>>
>>> Just for the hell of it I'm going to show you the key part of an
>>> argument that does not rely on assuming a non-existent function.
>>> Instead the conclusion of reached by reasoning about the properties of a
>>> particular expression in the language.
>>>
>>> Consider the higher-order function
>>>
>>> void p(d, i)
>>> {
>>> if d(i, i)
>>> then skip
>>> else while true do skip od
>>> }
>>>
>>> with a function argument such that the partial application p(f) is the
>>> one-argument function that uses some function f to decide whether to halt
>>> or not. Now consider the expression f(p(f), p(f)). This is the
>>> condition that is tested in the 'if' of the computation p(f, p(f)).
>>>
>>> No matter what the function f is, if the expression f(p(f), p(f)) is
>>> either true, false or it has no value because it is itself a non-halting
>>> computation.
>>>
>>> If f(p(f), p(f)) is true, then the computation p(f, p(f)) is a halting
>>> one, and if f(p(f), p(f)) is false or has no value due to being itself a
>>> non-halting computation, then p(f, p(f)) is a non-halting computation.
>>>
>>> In other words, if the language is expressive enough to write the
>>> function p, it can't be used to write a non-halting decider.
>>>
>>> (Obviously a similar argument shows that no function written in this
>>> language can be a halt decider, but you flipped over to considering
>>> non-halting deciders, so I did as well.)
>>>
>>
>>
>> void Halts_Fooler(u32 P)
>> {
>> if (Halts(P, P))
>> HERE: goto HERE;
>> else
>> HALT
>> }
>>
>>
>> bool Halts(u32 P, u32 I)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>> return false // Non halting behavior detected
>> else
>> return true; // Input has already halted
>> }
>>
>> When the halt decider does not make its halting decision until after
>> the input program has stopped running then the conventional halting
>> problem trick: "Do the opposite of whatever the halt decider decides"
>> cannot possibly make halting undecidable.
>
> This fails for the reasons that I and other have pointed out.
Try and describe an execution trace showing the details of how it would
fail and then I can point out exactly where you went wrong.
> You
> appear now to be in output only mode. Not only that, it's cut and paste
> output.
>
When people simply always dismiss whatever I say out-of-hand without any
review I continually persist until they finally stop ignoring what I say
and provide a review.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 5 of 8 — ← Prev page 1 2 3 4 [5] 6 7 8 Next page →
Back to top | Article view | comp.theory
csiph-web