Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #32496 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-05-01 11:30 -0500 |
| Last post | 2021-05-02 21:46 +0100 |
| Articles | 20 on this page of 92 — 7 participants |
Back to article view | Back to comp.theory
Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 11:30 -0500
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 11:37 -0500
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 12:40 -0500
Re: Mutual agreement on the definition of a [computation] in computer science Richard Damon <Richard@Damon-Family.org> - 2021-05-01 14:55 -0400
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 14:09 -0500
Re: Mutual agreement on the definition of a [computation] in computer science Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-01 22:42 +0100
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 17:32 -0500
Re: Mutual agreement on the definition of a [computation] in computer science Richard Damon <Richard@Damon-Family.org> - 2021-05-01 18:43 -0400
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 18:16 -0500
Re: Mutual agreement on the definition of a [computation] in computer science Richard Damon <Richard@Damon-Family.org> - 2021-05-01 21:20 -0400
Re: Mutual agreement on the definition of a [computation] in computer science Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-02 00:49 +0100
Re: Mutual agreement on the definition of a [computation] in computer science Richard Damon <Richard@Damon-Family.org> - 2021-05-01 18:02 -0400
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 17:49 -0500
Re: Mutual agreement on the definition of a [computation] in computer science André G. Isaak <agisaak@gm.invalid> - 2021-05-01 17:28 -0600
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-01 18:42 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-02 01:51 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-01 20:05 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-02 02:20 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-01 20:42 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-01 22:10 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-02 03:30 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-01 23:36 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-02 07:51 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-02 21:38 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-02 17:11 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-03 00:53 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-02 19:45 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-02 20:56 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-02 20:55 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-03 13:43 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-03 09:06 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-03 10:34 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-04 00:58 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-04 10:12 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-04 21:57 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Jeff Barnett <jbb@notatt.com> - 2021-05-03 11:39 -0600
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-02 17:41 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-03 00:52 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-02 19:34 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-02 20:49 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-03 17:23 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-03 14:00 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-03 15:23 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-04 09:53 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-04 11:21 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-04 10:28 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-04 11:40 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-04 17:11 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-04 11:23 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-04 12:40 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-04 11:46 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-04 13:17 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-04 21:47 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-04 17:31 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-04 23:21 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-04 00:49 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-04 10:09 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-04 10:45 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-04 19:50 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-04 10:04 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-04 11:22 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-04 10:31 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-04 11:46 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-04 19:56 +0100
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-02 20:44 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] André G. Isaak <agisaak@gm.invalid> - 2021-05-01 21:14 -0600
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-02 00:04 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] André G. Isaak <agisaak@gm.invalid> - 2021-05-01 23:27 -0600
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] olcott <NoOne@NoWhere.com> - 2021-05-02 12:47 -0500
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-02 14:38 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-01 21:40 -0400
Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] Richard Damon <Richard@Damon-Family.org> - 2021-05-01 21:35 -0400
Re: Mutual agreement on the definition of a [computation] in computer science Richard Damon <Richard@Damon-Family.org> - 2021-05-01 21:29 -0400
Re: Mutual agreement on the definition of a [computation] in computer science Richard Damon <Richard@Damon-Family.org> - 2021-05-01 14:49 -0400
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 14:02 -0500
Re: Mutual agreement on the definition of a [computation] in computer science Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-01 22:50 +0100
Re: Mutual agreement on the definition of a [computation] in computer science Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-01 18:22 +0000
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 13:35 -0500
Re: Mutual agreement on the definition of a [computation] in computer science Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-01 22:39 +0100
Re: Mutual agreement on the definition of a [computation] in computer science Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-01 22:49 +0100
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 18:35 -0500
Re: Mutual agreement on the definition of a [computation] in computer science Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-02 01:56 +0100
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 20:22 -0500
Re: Mutual agreement on the definition of a [computation] in computer science Richard Damon <Richard@Damon-Family.org> - 2021-05-01 21:45 -0400
Re: Mutual agreement on the definition of a [computation] in computer science Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-02 02:53 +0100
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-01 23:55 -0500
Re: Mutual agreement on the definition of a [computation] in computer science André G. Isaak <agisaak@gm.invalid> - 2021-05-01 23:07 -0600
Re: Mutual agreement on the definition of a [computation] in computer science Richard Damon <Richard@Damon-Family.org> - 2021-05-02 08:10 -0400
Re: Mutual agreement on the definition of a [computation] in computer science Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-02 20:29 +0100
Re: Mutual agreement on the definition of a [computation] in computer science olcott <NoOne@NoWhere.com> - 2021-05-02 14:34 -0500
Re: Mutual agreement on the definition of a [computation] in computer science Richard Damon <Richard@Damon-Family.org> - 2021-05-02 15:48 -0400
Re: Mutual agreement on the definition of a [computation] in computer science Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-02 21:46 +0100
Page 2 of 5 — ← Prev page 1 [2] 3 4 5 Next page →
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-02 03:30 +0100 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <871rapamv1.fsf@bsb.me.uk> |
| In reply to | #32546 |
olcott <NoOne@NoWhere.com> writes: > On 5/1/2021 8:20 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> No H_Hat() in the universe ever stops running unless its otherwise >>>>> infinite recursion is aborted at some point. >>>> >>>> This is just a silly word game. What a computation would do "otherwise" >>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or >>>> why. It is a finite computation, and should be reported as such. >>> >>> So in other words you believe that it is ridiculous for anyone to ever >>> consider defining a partial halt decider because everyone agrees that >>> is cannot be done perfectly so why bother doing this at all. >> >> No. I am saying that your wording is silly because it attempts to >> justify the wrong answer using another, different, computation. >> H_Hat(H_Hat) is finite. I see you don't dispute these facts. > If the execution trace of function X() called by function Y() shows: > (1) Function X() is called twice in sequence from the same machine address of Y(). > (2) With the same parameters to X(). > (3) With no conditional branch or indexed jump instructions in Y(). > (4) With no function call returns from X(). > then the function call from Y() to X() is infinitely recursive. > > The above criteria does correctly decide infinite recursion. What has this got to do with the computation H_Hat(H_Hat) (the real one, not the one you posted recently to poison the well)? It calls no functions that call H_Hat. In the world of C and x86 code, that means it is not recursive at all. If you are tracing a call to Halts, then that is not relevant. If Halts is recursive, that says nothing about the computation that matters. Other than explain why it can't matter, I won't discuss your traces without seeing the code being traced, and the code the generates the traces. You lost the right to be considered an honest reporter of your own work when you claimed to have two "actual Turing machines", "fully encoded", "exactly and precisely as in Linz". > The above criteria does correctly decide infinite recursion. > The above criteria does correctly decide infinite recursion. > > Every call from H_Hat() to Halts() meets this criteria. > Every call from H_Hat() to Halts() meets this criteria. > Every call from H_Hat() to Halts() meets this criteria. > > Ignoring this key fact is no form of correct rebuttal. You ignored the key facts I put to you. These were facts that you told me so you are stuck with them until you correct the record. You told me that: (a) Halts(H_Hat, H_Hat) is false, and (b) H_Hat(H_Hat) is a finite computation. (You actually said "the input to Halts is finite" but you meant what (b) says). No trace can make the wrong answer correct. This has not changed since last year, and until you correct the record, you are reduced to trying to find linguistic circumlocutions to explain why the wrong answer is the right answer. > Ignoring this key fact is no form of correct rebuttal. > Ignoring this key fact is no form of correct rebuttal. This repetition is even sillier than your original silly words. Please don't stop doing it. It's important that people see it in the record. I recommend ALL CAPS and at least a dozen repetitions. >> Halts(H_Hat, H_Hat) should be true, but you >> have written Halts so that it's false and you justify that wrong answer >> by what would happen were things not as they are. It's flagrant >> silliness. > >> When you find yourself starting off "So in other words you believe..." >> you should stop and ask yourself, "what point am I trying to avoid by >> putting words into my interlocutor's mounth?". -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-01 23:36 -0500 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <CcSdnSKKCqSgsRP9nZ2dnUU7-cXNnZ2d@giganews.com> |
| In reply to | #32551 |
On 5/1/2021 9:30 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 5/1/2021 8:20 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> No H_Hat() in the universe ever stops running unless its otherwise >>>>>> infinite recursion is aborted at some point. >>>>> >>>>> This is just a silly word game. What a computation would do "otherwise" >>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or >>>>> why. It is a finite computation, and should be reported as such. >>>> >>>> So in other words you believe that it is ridiculous for anyone to ever >>>> consider defining a partial halt decider because everyone agrees that >>>> is cannot be done perfectly so why bother doing this at all. >>> >>> No. I am saying that your wording is silly because it attempts to >>> justify the wrong answer using another, different, computation. >>> H_Hat(H_Hat) is finite. > > I see you don't dispute these facts. > >> If the execution trace of function X() called by function Y() shows: >> (1) Function X() is called twice in sequence from the same machine address of Y(). >> (2) With the same parameters to X(). >> (3) With no conditional branch or indexed jump instructions in Y(). >> (4) With no function call returns from X(). >> then the function call from Y() to X() is infinitely recursive. >> >> The above criteria does correctly decide infinite recursion. > > What has this got to do with the computation H_Hat(H_Hat) (the real one, > not the one you posted recently to poison the well)? It calls no > functions that call H_Hat. In the world of C and x86 code, that means > it is not recursive at all. > > If you are tracing a call to Halts, then that is not relevant. If > Halts is recursive, that says nothing about the computation that > matters. > > Other than explain why it can't matter, I won't discuss your traces > without seeing the code being traced, and the code the generates the > traces. You lost the right to be considered an honest reporter of your > own work when you claimed to have two "actual Turing machines", "fully > encoded", "exactly and precisely as in Linz". > >> The above criteria does correctly decide infinite recursion. >> The above criteria does correctly decide infinite recursion. >> >> Every call from H_Hat() to Halts() meets this criteria. >> Every call from H_Hat() to Halts() meets this criteria. >> Every call from H_Hat() to Halts() meets this criteria. >> >> Ignoring this key fact is no form of correct rebuttal. > > You ignored the key facts I put to you. These were facts that you told > me so you are stuck with them until you correct the record. The key fact is that every time H_Hat() calls Halts() it meets the above criteria of infinite recursion, you can dodge this fact but you cannot correctly refute this fact. The key "facts" that you presented dodged rather than addressed this point. You are bright enough to confirm that the above <is> correct infinite recursion criteria. You also know that when complete infinite recursion criteria is met then we <have> infinite recursion. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-02 07:51 -0400 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <PmwjI.178495$ST2.62135@fx47.iad> |
| In reply to | #32553 |
On 5/2/21 12:36 AM, olcott wrote:
> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>> infinite recursion is aborted at some point.
>>>>>>
>>>>>> This is just a silly word game. What a computation would do
>>>>>> "otherwise"
>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>
>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>> consider defining a partial halt decider because everyone agrees that
>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>
>>>> No. I am saying that your wording is silly because it attempts to
>>>> justify the wrong answer using another, different, computation.
>>>> H_Hat(H_Hat) is finite.
>>
>> I see you don't dispute these facts.
>>
>>> If the execution trace of function X() called by function Y() shows:
>>> (1) Function X() is called twice in sequence from the same machine
>>> address of Y().
>>> (2) With the same parameters to X().
>>> (3) With no conditional branch or indexed jump instructions in Y().
>>> (4) With no function call returns from X().
>>> then the function call from Y() to X() is infinitely recursive.
>>>
>>> The above criteria does correctly decide infinite recursion.
>>
>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>> not the one you posted recently to poison the well)? It calls no
>> functions that call H_Hat. In the world of C and x86 code, that means
>> it is not recursive at all.
>>
>> If you are tracing a call to Halts, then that is not relevant. If
>> Halts is recursive, that says nothing about the computation that
>> matters.
>>
>> Other than explain why it can't matter, I won't discuss your traces
>> without seeing the code being traced, and the code the generates the
>> traces. You lost the right to be considered an honest reporter of your
>> own work when you claimed to have two "actual Turing machines", "fully
>> encoded", "exactly and precisely as in Linz".
>>
>>> The above criteria does correctly decide infinite recursion.
>>> The above criteria does correctly decide infinite recursion.
>>>
>>> Every call from H_Hat() to Halts() meets this criteria.
>>> Every call from H_Hat() to Halts() meets this criteria.
>>> Every call from H_Hat() to Halts() meets this criteria.
>>>
>>> Ignoring this key fact is no form of correct rebuttal.
>>
>
>> You ignored the key facts I put to you. These were facts that you told
>> me so you are stuck with them until you correct the record.
>
> The key fact is that every time H_Hat() calls Halts() it meets the above
> criteria of infinite recursion, you can dodge this fact but you cannot
> correctly refute this fact.
>
> The key "facts" that you presented dodged rather than addressed this
> point. You are bright enough to confirm that the above <is> correct
> infinite recursion criteria. You also know that when complete infinite
> recursion criteria is met then we <have> infinite recursion.
>
>
First, it is NOT recursion, because Halts doesn't 'Call' H_Hat, it know
nothing of H_Hat in its algorithm. It is NOT recursion.
Second, if you do redefine the simulation to be like a call to get
recursion, then for H_Hat to call Halts to be infinite recursion, so
would Halts 'calling' H_Hat, so Halts would be a non-Halting
computation, and thus not a decider.
THis is NOT what happens.
If fact, YOU even published a trace of this execution showing that
H_Hat, when not being run under a halt decider, so NOT able to be
'aborted', actually comes to a Halt by itself, thus showing it to be a
Halting Computation: (Yes, the Halts within H_Hat reports that it
aborted its simulation of its copy of H_Hat, but that isn't aborting the
H_Hat that we are looking at).
On 4/27/21 12:55 AM, olcott wrote:
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01) 55 push ebp
> [00000b99](02) 8bec mov ebp,esp
> [00000b9b](01) 51 push ecx
> [00000b9c](03) 8b4508 mov eax,[ebp+08]
> [00000b9f](01) 50 push eax
> [00000ba0](03) 8b4d08 mov ecx,[ebp+08]
> [00000ba3](01) 51 push ecx
> [00000ba4](05) e88ffdffff call 00000938
> [00000ba9](03) 83c408 add esp,+08
> [00000bac](03) 8945fc mov [ebp-04],eax
> [00000baf](04) 837dfc00 cmp dword [ebp-04],+00
> [00000bb3](02) 7402 jz 00000bb7
> [00000bb5](02) ebfe jmp 00000bb5
> [00000bb7](02) 8be5 mov esp,ebp
> [00000bb9](01) 5d pop ebp
> [00000bba](01) c3 ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01) 55 push ebp
> [00000bc9](02) 8bec mov ebp,esp
> [00000bcb](05) 68980b0000 push 00000b98
> [00000bd0](05) e8c3ffffff call 00000b98
> [00000bd5](03) 83c404 add esp,+04
> [00000bd8](02) 33c0 xor eax,eax
> [00000bda](01) 5d pop ebp
> [00000bdb](01) c3 ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01) 55 push ebp
> ...[00000bc9][001015d4][00000000](02) 8bec mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05) 68980b0000 push
> 00000b98
> ...[00000bd0][001015cc][00000bd5](05) e8c3ffffff call
> 00000b98
> ...[00000b98][001015c8][001015d4](01) 55 push ebp
> ...[00000b99][001015c8][001015d4](02) 8bec mov ebp,esp
> ...[00000b9b][001015c4][00000000](01) 51 push ecx
> ...[00000b9c][001015c4][00000000](03) 8b4508 mov
> eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01) 50 push eax
> ...[00000ba0][001015c0][00000b98](03) 8b4d08 mov
> ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01) 51 push ecx
> ...[00000ba4][001015b8][00000ba9](05) e88ffdffff call
> 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01) 55 push ebp
> ...[00000b99][00211674][00211678](02) 8bec mov ebp,esp
> ...[00000b9b][00211670][00201644](01) 51 push ecx
> ...[00000b9c][00211670][00201644](03) 8b4508 mov
> eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01) 50 push eax
> ...[00000ba0][0021166c][00000b98](03) 8b4d08 mov
> ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01) 51 push ecx
> ...[00000ba4][00211664][00000ba9](05) e88ffdffff call
> 00000938
> ...[00000b98][0025c09c][0025c0a0](01) 55 push ebp
> ...[00000b99][0025c09c][0025c0a0](02) 8bec mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01) 51 push ecx
> ...[00000b9c][0025c098][0024c06c](03) 8b4508 mov
> eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01) 50 push eax
> ...[00000ba0][0025c094][00000b98](03) 8b4d08 mov
> ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01) 51 push ecx
> ...[00000ba4][0025c08c][00000ba9](05) e88ffdffff call
> 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> ...[00000bac][001015c4][00000000](03) 8945fc mov
> [ebp-04],eax
> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword
> [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> ...[00000bba][001015d0][00000b98](01) c3 ret
> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> ...[00000bda][001015d8][00100000](01) 5d pop ebp
> ...[00000bdb][001015dc][00000098](01) c3 ret
> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)
>
You are using a WRONG definition of Halting, or at least a wrong
argument to try to say that it isn't halting.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-02 21:38 +0100 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <87wnsg7twk.fsf@bsb.me.uk> |
| In reply to | #32553 |
olcott <NoOne@NoWhere.com> writes: > On 5/1/2021 9:30 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> No H_Hat() in the universe ever stops running unless its otherwise >>>>>>> infinite recursion is aborted at some point. >>>>>> >>>>>> This is just a silly word game. What a computation would do "otherwise" >>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or >>>>>> why. It is a finite computation, and should be reported as such. >>>>> >>>>> So in other words you believe that it is ridiculous for anyone to ever >>>>> consider defining a partial halt decider because everyone agrees that >>>>> is cannot be done perfectly so why bother doing this at all. >>>> >>>> No. I am saying that your wording is silly because it attempts to >>>> justify the wrong answer using another, different, computation. >>>> H_Hat(H_Hat) is finite. >> >> I see you don't dispute these facts. Good to see these facts confirmed by you once again. If you dispute that you justify giving the wrong answer using another related computation, all you need to do is say so (and correct the record where you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts denote a finite computation). >>> The above criteria does correctly decide infinite recursion. >> >> What has this got to do with the computation H_Hat(H_Hat) (the real one, >> not the one you posted recently to poison the well)? It calls no >> functions that call H_Hat. In the world of C and x86 code, that means >> it is not recursive at all. >> You ignored the key facts I put to you. These were facts that you told >> me so you are stuck with them until you correct the record. > > The key fact is that every time H_Hat() calls Halts() it meets the > above criteria of infinite recursion, you can dodge this fact but you > cannot correctly refute this fact. I am not dodging it -- I am telling you it's a lie. I started out being polite and technical, but it amounts to the same thing: if the trace shows recursion, it is a fake. The only clue you have given us at to what Halts does made it plain that there is no recursive call, so the trace you show is, as far anyone can tell, a fiction, a lie, published in order to be able to show /something/ when you dare not show the code. If the trace shows a recursive call, it does not comport with what you have published about Halts and that makes one or other of those (the sketch of Halts or the trace) a plain deception. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-02 17:11 -0400 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <OzEjI.193957$J_5.100214@fx46.iad> |
| In reply to | #32592 |
On 5/2/21 4:38 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 5/1/2021 9:30 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote: >>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>> >>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise >>>>>>>> infinite recursion is aborted at some point. >>>>>>> >>>>>>> This is just a silly word game. What a computation would do "otherwise" >>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or >>>>>>> why. It is a finite computation, and should be reported as such. >>>>>> >>>>>> So in other words you believe that it is ridiculous for anyone to ever >>>>>> consider defining a partial halt decider because everyone agrees that >>>>>> is cannot be done perfectly so why bother doing this at all. >>>>> >>>>> No. I am saying that your wording is silly because it attempts to >>>>> justify the wrong answer using another, different, computation. >>>>> H_Hat(H_Hat) is finite. >>> >>> I see you don't dispute these facts. > > Good to see these facts confirmed by you once again. If you dispute > that you justify giving the wrong answer using another related > computation, all you need to do is say so (and correct the record where > you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts > denote a finite computation). > >>>> The above criteria does correctly decide infinite recursion. >>> >>> What has this got to do with the computation H_Hat(H_Hat) (the real one, >>> not the one you posted recently to poison the well)? It calls no >>> functions that call H_Hat. In the world of C and x86 code, that means >>> it is not recursive at all. > >>> You ignored the key facts I put to you. These were facts that you told >>> me so you are stuck with them until you correct the record. >> >> The key fact is that every time H_Hat() calls Halts() it meets the >> above criteria of infinite recursion, you can dodge this fact but you >> cannot correctly refute this fact. > > I am not dodging it -- I am telling you it's a lie. I started out being > polite and technical, but it amounts to the same thing: if the trace > shows recursion, it is a fake. The only clue you have given us at to > what Halts does made it plain that there is no recursive call, so the > trace you show is, as far anyone can tell, a fiction, a lie, published > in order to be able to show /something/ when you dare not show the code. > If the trace shows a recursive call, it does not comport with what you > have published about Halts and that makes one or other of those (the > sketch of Halts or the trace) a plain deception. > Actually, I am not sure I would call it a 'lie' but just a very different model of reality. From what I can infer from what we are told, x86utm is designed as a simulator/halt decider designed to handle systems with this sort of nested simulations. Halts is not really a 'function' in the normal sense, but an entry point into the simulator that converts the call to it to simulate/decide for a provided input into a real 'simulated' call with some book keeping. This sort of definition would generate the traces like he provides. It also explains why you can't make a copy of Halts, as Halts isn't really an self contained Computation, but just an entry point into the OS which considers itself outside the system. This of course says that Halts is NOT the equivalent of a Turing Machine in a simple way, and thus H_Hat isn't really built the right way either. To make a Turing Machine out of Halts, you likely need to wrap the whole x86utm OS into the machine, and thus we go back to one of my proposals where H_Hat needs to exec() x86utm to make the call. Of course, as I recently pointed out, all these errors don't actually let him properly decide on H_Hat. As long as the function call to Halts acts like a computaton, always returning the same answer to all calls with the same formal parameters, and we use the real definition of Halting, that being what happens when we run the machine unimpaired, we can show that Halts gets the answer wrong. All he does with this subterfuge is to open the door for this crazy notion that by confusing where Halts is actually operating, we can be hornswaggled into believing that the operation of the Halts called within the operation of H_Hat somehow doesn't count as being part of H_Hat and thus it needing to perform the stopping means that H_Hat won't stop on its own, and thus would seem to be non-Halting.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-03 00:53 +0100 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <87fsz47kvc.fsf@bsb.me.uk> |
| In reply to | #32594 |
Richard Damon <Richard@Damon-Family.org> writes:
> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>
>>>>>>>> This is just a silly word game. What a computation would do "otherwise"
>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>>
>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>
>>>>>> No. I am saying that your wording is silly because it attempts to
>>>>>> justify the wrong answer using another, different, computation.
>>>>>> H_Hat(H_Hat) is finite.
>>>>
>>>> I see you don't dispute these facts.
>>
>> Good to see these facts confirmed by you once again. If you dispute
>> that you justify giving the wrong answer using another related
>> computation, all you need to do is say so (and correct the record where
>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>> denote a finite computation).
>>
>>>>> The above criteria does correctly decide infinite recursion.
>>>>
>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>> not the one you posted recently to poison the well)? It calls no
>>>> functions that call H_Hat. In the world of C and x86 code, that means
>>>> it is not recursive at all.
>>
>>>> You ignored the key facts I put to you. These were facts that you told
>>>> me so you are stuck with them until you correct the record.
>>>
>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>> above criteria of infinite recursion, you can dodge this fact but you
>>> cannot correctly refute this fact.
>>
>> I am not dodging it -- I am telling you it's a lie. I started out being
>> polite and technical, but it amounts to the same thing: if the trace
>> shows recursion, it is a fake. The only clue you have given us at to
>> what Halts does made it plain that there is no recursive call, so the
>> trace you show is, as far anyone can tell, a fiction, a lie, published
>> in order to be able to show /something/ when you dare not show the code.
>> If the trace shows a recursive call, it does not comport with what you
>> have published about Halts and that makes one or other of those (the
>> sketch of Halts or the trace) a plain deception.
>
> Actually, I am not sure I would call it a 'lie' but just a very
> different model of reality. From what I can infer from what we are told,
> x86utm is designed as a simulator/halt decider designed to handle
> systems with this sort of nested simulations.
>
> Halts is not really a 'function' in the normal sense, but an entry point
> into the simulator that converts the call to it to simulate/decide for a
> provided input into a real 'simulated' call with some book keeping.
The best information we have about Halts (as far as I know) is a sketch
showing a loop that single-steps a simulation and a function call that
assesses whether to end the loop:
bool Halts(u32 P, u32 I)
{
bool Halted = false;
bool Aborted = false;
while (!Halted && !Aborted)
{
Halted = DebugStep(P, I);
Aborted = Needs_To_Be_Aborted();
}
return !Aborted;
}
If the trace shows a recursive call, I'd call that a lie. Something is
not as we've been led to believe.
Mind you, I refuse to look at the trace, so I am going by what PO says
about it. Have I misunderstood him? Does it not show Halts(H_Hat,
H_Hat) making recursive calls?
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-02 19:45 -0500 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <k9ydne8WhMMN2hL9nZ2dnUU7-T3NnZ2d@giganews.com> |
| In reply to | #32599 |
On 5/2/2021 6:53 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>
>>>>>>>>> This is just a silly word game. What a computation would do "otherwise"
>>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>>>
>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>
>>>>>>> No. I am saying that your wording is silly because it attempts to
>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>> H_Hat(H_Hat) is finite.
>>>>>
>>>>> I see you don't dispute these facts.
>>>
>>> Good to see these facts confirmed by you once again. If you dispute
>>> that you justify giving the wrong answer using another related
>>> computation, all you need to do is say so (and correct the record where
>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>> denote a finite computation).
>>>
>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>
>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>> not the one you posted recently to poison the well)? It calls no
>>>>> functions that call H_Hat. In the world of C and x86 code, that means
>>>>> it is not recursive at all.
>>>
>>>>> You ignored the key facts I put to you. These were facts that you told
>>>>> me so you are stuck with them until you correct the record.
>>>>
>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>> cannot correctly refute this fact.
>>>
>>> I am not dodging it -- I am telling you it's a lie. I started out being
>>> polite and technical, but it amounts to the same thing: if the trace
>>> shows recursion, it is a fake. The only clue you have given us at to
>>> what Halts does made it plain that there is no recursive call, so the
>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>> in order to be able to show /something/ when you dare not show the code.
>>> If the trace shows a recursive call, it does not comport with what you
>>> have published about Halts and that makes one or other of those (the
>>> sketch of Halts or the trace) a plain deception.
>>
>> Actually, I am not sure I would call it a 'lie' but just a very
>> different model of reality. From what I can infer from what we are told,
>> x86utm is designed as a simulator/halt decider designed to handle
>> systems with this sort of nested simulations.
>>
>> Halts is not really a 'function' in the normal sense, but an entry point
>> into the simulator that converts the call to it to simulate/decide for a
>> provided input into a real 'simulated' call with some book keeping.
>
> The best information we have about Halts (as far as I know) is a sketch
> showing a loop that single-steps a simulation and a function call that
> assesses whether to end the loop:
>
> bool Halts(u32 P, u32 I)
> {
> bool Halted = false;
> bool Aborted = false;
> while (!Halted && !Aborted)
> {
> Halted = DebugStep(P, I);
> Aborted = Needs_To_Be_Aborted();
> }
> return !Aborted;
> }
>
> If the trace shows a recursive call, I'd call that a lie. Something is
> not as we've been led to believe.
>
> Mind you, I refuse to look at the trace, so I am going by what PO says
> about it. Have I misunderstood him? Does it not show Halts(H_Hat,
> H_Hat) making recursive calls?
>
In the above case it only shows that actual execution trace of whatever
is input, unless the input must be aborted.
Infinitely nested simulations match the [Infinite Recursion] dynamic
behavior pattern, and the halt decider does not need to know the
difference.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-02 20:56 -0400 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <TSHjI.67049$b27.57508@fx03.iad> |
| In reply to | #32602 |
On 5/2/21 8:45 PM, olcott wrote:
> On 5/2/2021 6:53 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its
>>>>>>>>>>> otherwise
>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>
>>>>>>>>>> This is just a silly word game. What a computation would do
>>>>>>>>>> "otherwise"
>>>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter
>>>>>>>>>> how or
>>>>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>>>>
>>>>>>>>> So in other words you believe that it is ridiculous for anyone
>>>>>>>>> to ever
>>>>>>>>> consider defining a partial halt decider because everyone
>>>>>>>>> agrees that
>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>
>>>>>>>> No. I am saying that your wording is silly because it attempts to
>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>
>>>>>> I see you don't dispute these facts.
>>>>
>>>> Good to see these facts confirmed by you once again. If you dispute
>>>> that you justify giving the wrong answer using another related
>>>> computation, all you need to do is say so (and correct the record where
>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>> denote a finite computation).
>>>>
>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>
>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the
>>>>>> real one,
>>>>>> not the one you posted recently to poison the well)? It calls no
>>>>>> functions that call H_Hat. In the world of C and x86 code, that
>>>>>> means
>>>>>> it is not recursive at all.
>>>>
>>>>>> You ignored the key facts I put to you. These were facts that you
>>>>>> told
>>>>>> me so you are stuck with them until you correct the record.
>>>>>
>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>>> cannot correctly refute this fact.
>>>>
>>>> I am not dodging it -- I am telling you it's a lie. I started out
>>>> being
>>>> polite and technical, but it amounts to the same thing: if the trace
>>>> shows recursion, it is a fake. The only clue you have given us at to
>>>> what Halts does made it plain that there is no recursive call, so the
>>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>>> in order to be able to show /something/ when you dare not show the
>>>> code.
>>>> If the trace shows a recursive call, it does not comport with what you
>>>> have published about Halts and that makes one or other of those (the
>>>> sketch of Halts or the trace) a plain deception.
>>>
>>> Actually, I am not sure I would call it a 'lie' but just a very
>>> different model of reality. From what I can infer from what we are told,
>>> x86utm is designed as a simulator/halt decider designed to handle
>>> systems with this sort of nested simulations.
>>>
>>> Halts is not really a 'function' in the normal sense, but an entry point
>>> into the simulator that converts the call to it to simulate/decide for a
>>> provided input into a real 'simulated' call with some book keeping.
>>
>> The best information we have about Halts (as far as I know) is a sketch
>> showing a loop that single-steps a simulation and a function call that
>> assesses whether to end the loop:
>>
>> bool Halts(u32 P, u32 I)
>> {
>> bool Halted = false;
>> bool Aborted = false;
>> while (!Halted && !Aborted)
>> {
>> Halted = DebugStep(P, I);
>> Aborted = Needs_To_Be_Aborted();
>> }
>> return !Aborted;
>> }
>>
>> If the trace shows a recursive call, I'd call that a lie. Something is
>> not as we've been led to believe.
>>
>> Mind you, I refuse to look at the trace, so I am going by what PO says
>> about it. Have I misunderstood him? Does it not show Halts(H_Hat,
>> H_Hat) making recursive calls?
>>
>
> In the above case it only shows that actual execution trace of whatever
> is input, unless the input must be aborted.
>
> Infinitely nested simulations match the [Infinite Recursion] dynamic
> behavior pattern, and the halt decider does not need to know the
> difference.
>
>
Except that it doesn't, as it omits code that is part of the
computation, namely the contents of the Halts called by H_Hat.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-02 20:55 -0400 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <XRHjI.67048$b27.14253@fx03.iad> |
| In reply to | #32599 |
On 5/2/21 7:53 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>
>>>>>>>>> This is just a silly word game. What a computation would do "otherwise"
>>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>>>
>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>
>>>>>>> No. I am saying that your wording is silly because it attempts to
>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>> H_Hat(H_Hat) is finite.
>>>>>
>>>>> I see you don't dispute these facts.
>>>
>>> Good to see these facts confirmed by you once again. If you dispute
>>> that you justify giving the wrong answer using another related
>>> computation, all you need to do is say so (and correct the record where
>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>> denote a finite computation).
>>>
>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>
>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>> not the one you posted recently to poison the well)? It calls no
>>>>> functions that call H_Hat. In the world of C and x86 code, that means
>>>>> it is not recursive at all.
>>>
>>>>> You ignored the key facts I put to you. These were facts that you told
>>>>> me so you are stuck with them until you correct the record.
>>>>
>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>> cannot correctly refute this fact.
>>>
>>> I am not dodging it -- I am telling you it's a lie. I started out being
>>> polite and technical, but it amounts to the same thing: if the trace
>>> shows recursion, it is a fake. The only clue you have given us at to
>>> what Halts does made it plain that there is no recursive call, so the
>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>> in order to be able to show /something/ when you dare not show the code.
>>> If the trace shows a recursive call, it does not comport with what you
>>> have published about Halts and that makes one or other of those (the
>>> sketch of Halts or the trace) a plain deception.
>>
>> Actually, I am not sure I would call it a 'lie' but just a very
>> different model of reality. From what I can infer from what we are told,
>> x86utm is designed as a simulator/halt decider designed to handle
>> systems with this sort of nested simulations.
>>
>> Halts is not really a 'function' in the normal sense, but an entry point
>> into the simulator that converts the call to it to simulate/decide for a
>> provided input into a real 'simulated' call with some book keeping.
>
> The best information we have about Halts (as far as I know) is a sketch
> showing a loop that single-steps a simulation and a function call that
> assesses whether to end the loop:
>
> bool Halts(u32 P, u32 I)
> {
> bool Halted = false;
> bool Aborted = false;
> while (!Halted && !Aborted)
> {
> Halted = DebugStep(P, I);
> Aborted = Needs_To_Be_Aborted();
> }
> return !Aborted;
> }
>
> If the trace shows a recursive call, I'd call that a lie. Something is
> not as we've been led to believe.
>
> Mind you, I refuse to look at the trace, so I am going by what PO says
> about it. Have I misunderstood him? Does it not show Halts(H_Hat,
> H_Hat) making recursive calls?
>
Yes, he has provided that sketch for Halts, which actually implies if
you think about what he seems to be doing that at least DebugStep isn't
a computation, but an access to the bigger emulator with a lot of hidden
state.
It CAN'T be a simple computation, as something needs to be keeping track
of each step, and Needs_To_Be_aborted() doesn't have anything to make
its decision on.
This impies also that Halts isn't a Compuation either.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-03 13:43 +0100 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <87a6pc6l9m.fsf@bsb.me.uk> |
| In reply to | #32604 |
Richard Damon <Richard@Damon-Family.org> writes:
> On 5/2/21 7:53 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>
>>>>>>>>>> This is just a silly word game. What a computation would do "otherwise"
>>>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>>>>
>>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>
>>>>>>>> No. I am saying that your wording is silly because it attempts to
>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>
>>>>>> I see you don't dispute these facts.
>>>>
>>>> Good to see these facts confirmed by you once again. If you dispute
>>>> that you justify giving the wrong answer using another related
>>>> computation, all you need to do is say so (and correct the record where
>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>> denote a finite computation).
>>>>
>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>
>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>>> not the one you posted recently to poison the well)? It calls no
>>>>>> functions that call H_Hat. In the world of C and x86 code, that means
>>>>>> it is not recursive at all.
>>>>
>>>>>> You ignored the key facts I put to you. These were facts that you told
>>>>>> me so you are stuck with them until you correct the record.
>>>>>
>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>>> cannot correctly refute this fact.
>>>>
>>>> I am not dodging it -- I am telling you it's a lie. I started out being
>>>> polite and technical, but it amounts to the same thing: if the trace
>>>> shows recursion, it is a fake. The only clue you have given us at to
>>>> what Halts does made it plain that there is no recursive call, so the
>>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>>> in order to be able to show /something/ when you dare not show the code.
>>>> If the trace shows a recursive call, it does not comport with what you
>>>> have published about Halts and that makes one or other of those (the
>>>> sketch of Halts or the trace) a plain deception.
>>>
>>> Actually, I am not sure I would call it a 'lie' but just a very
>>> different model of reality. From what I can infer from what we are told,
>>> x86utm is designed as a simulator/halt decider designed to handle
>>> systems with this sort of nested simulations.
>>>
>>> Halts is not really a 'function' in the normal sense, but an entry point
>>> into the simulator that converts the call to it to simulate/decide for a
>>> provided input into a real 'simulated' call with some book keeping.
>>
>> The best information we have about Halts (as far as I know) is a sketch
>> showing a loop that single-steps a simulation and a function call that
>> assesses whether to end the loop:
>>
>> bool Halts(u32 P, u32 I)
>> {
>> bool Halted = false;
>> bool Aborted = false;
>> while (!Halted && !Aborted)
>> {
>> Halted = DebugStep(P, I);
>> Aborted = Needs_To_Be_Aborted();
>> }
>> return !Aborted;
>> }
>>
>> If the trace shows a recursive call, I'd call that a lie. Something is
>> not as we've been led to believe.
>>
>> Mind you, I refuse to look at the trace, so I am going by what PO says
>> about it. Have I misunderstood him? Does it not show Halts(H_Hat,
>> H_Hat) making recursive calls?
>>
>
> Yes, he has provided that sketch for Halts, which actually implies if
> you think about what he seems to be doing that at least DebugStep isn't
> a computation, but an access to the bigger emulator with a lot of hidden
> state.
>
> It CAN'T be a simple computation, as something needs to be keeping track
> of each step, and Needs_To_Be_aborted() doesn't have anything to make
> its decision on.
Of course it has state. I think this concern about what is a simple
computation is a side issue. This was posted in reply to a challenge of
mine to write a function F(p, i) that returns true if p(i) halts and
false otherwise. All I said was that I would provide the confounding
case.
It does not matter how many side-effects Halts has, or what state it
uses or if it trawls the Internet for clues. It is possible to come up
with any number of tricks that can get round the usual construction, but
it is always possible to generate a confounding case that defeats them.
Of course, to do that in the face of the most cunning opponent would
require access to the real source code, and not a sketch.
But PO is not cunning, he is just silly. He was prepared to confirm
that, however it does it, Halts(Confound_Halts, Confound_Halts) returns
false, at the same time as confirming that arguments to Halts represent
a finite computation. This is 100% in line with his prior posts about
re-defining the terms involved in the problem, AKA, ignoring the
problem.
He has always been delightfully clear about this nonsense. False is
declared the correct answer for some halting computations because a
related computation (the one that "would not halt were it not halted")
justifies it. Early on, he was even more clear. False is correct
because of what happens when the Needs_To_Be_aborted line is commented
out. I suspect he thought that was too crude, so the verbal gymnastics
started.
(His is also a liar in that he told Mike Terry, point blank, that Halts
always returns, and always with the same value when given the same
arguments, but then he told me that Halts does not always return a value
at all, but I don't think that trick is actually being used. I can't
say, because all the detail are hidden from us.)
> This impies also that Halts isn't a Compuation either.
I was hoping you could say whether the trace shows recursive calls or
not rather then opening up the what is a computation on a messy system
like an x86!
If the trace shows recursive calls, then it doesn't comport with what he
said about Halts. If it shows the correct nested simulation, then it
will either just confirm what Halts returns or it will show he was lying
about that. And if he ever publishes a trace of the key computation
(H_Hat(H_Hat)) that will either show up some other lies or it will
confirm that Halts is indeed returning the wrong answer -- the answer PO
declares to be the right one.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-03 09:06 -0500 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <0aydnURwxLn1ng39nZ2dnUU7-QfNnZ2d@giganews.com> |
| In reply to | #32614 |
On 5/3/2021 7:43 AM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> On 5/2/21 7:53 PM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>>
>>>>>>>>>>> This is just a silly word game. What a computation would do "otherwise"
>>>>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>>>>>
>>>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>>
>>>>>>>>> No. I am saying that your wording is silly because it attempts to
>>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>>
>>>>>>> I see you don't dispute these facts.
>>>>>
>>>>> Good to see these facts confirmed by you once again. If you dispute
>>>>> that you justify giving the wrong answer using another related
>>>>> computation, all you need to do is say so (and correct the record where
>>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>>> denote a finite computation).
>>>>>
>>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>>
>>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>>>> not the one you posted recently to poison the well)? It calls no
>>>>>>> functions that call H_Hat. In the world of C and x86 code, that means
>>>>>>> it is not recursive at all.
>>>>>
>>>>>>> You ignored the key facts I put to you. These were facts that you told
>>>>>>> me so you are stuck with them until you correct the record.
>>>>>>
>>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>>>> cannot correctly refute this fact.
>>>>>
>>>>> I am not dodging it -- I am telling you it's a lie. I started out being
>>>>> polite and technical, but it amounts to the same thing: if the trace
>>>>> shows recursion, it is a fake. The only clue you have given us at to
>>>>> what Halts does made it plain that there is no recursive call, so the
>>>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>>>> in order to be able to show /something/ when you dare not show the code.
>>>>> If the trace shows a recursive call, it does not comport with what you
>>>>> have published about Halts and that makes one or other of those (the
>>>>> sketch of Halts or the trace) a plain deception.
>>>>
>>>> Actually, I am not sure I would call it a 'lie' but just a very
>>>> different model of reality. From what I can infer from what we are told,
>>>> x86utm is designed as a simulator/halt decider designed to handle
>>>> systems with this sort of nested simulations.
>>>>
>>>> Halts is not really a 'function' in the normal sense, but an entry point
>>>> into the simulator that converts the call to it to simulate/decide for a
>>>> provided input into a real 'simulated' call with some book keeping.
>>>
>>> The best information we have about Halts (as far as I know) is a sketch
>>> showing a loop that single-steps a simulation and a function call that
>>> assesses whether to end the loop:
>>>
>>> bool Halts(u32 P, u32 I)
>>> {
>>> bool Halted = false;
>>> bool Aborted = false;
>>> while (!Halted && !Aborted)
>>> {
>>> Halted = DebugStep(P, I);
>>> Aborted = Needs_To_Be_Aborted();
>>> }
>>> return !Aborted;
>>> }
>>>
>>> If the trace shows a recursive call, I'd call that a lie. Something is
>>> not as we've been led to believe.
>>>
>>> Mind you, I refuse to look at the trace, so I am going by what PO says
>>> about it. Have I misunderstood him? Does it not show Halts(H_Hat,
>>> H_Hat) making recursive calls?
>>>
>>
>> Yes, he has provided that sketch for Halts, which actually implies if
>> you think about what he seems to be doing that at least DebugStep isn't
>> a computation, but an access to the bigger emulator with a lot of hidden
>> state.
>>
>> It CAN'T be a simple computation, as something needs to be keeping track
>> of each step, and Needs_To_Be_aborted() doesn't have anything to make
>> its decision on.
>
> Of course it has state. I think this concern about what is a simple
> computation is a side issue. This was posted in reply to a challenge of
> mine to write a function F(p, i) that returns true if p(i) halts and
> false otherwise. All I said was that I would provide the confounding
> case.
>
> It does not matter how many side-effects Halts has, or what state it
> uses or if it trawls the Internet for clues. It is possible to come up
> with any number of tricks that can get round the usual construction, but
> it is always possible to generate a confounding case that defeats them.
> Of course, to do that in the face of the most cunning opponent would
> require access to the real source code, and not a sketch.
>
> But PO is not cunning, he is just silly. He was prepared to confirm
> that, however it does it, Halts(Confound_Halts, Confound_Halts) returns
> false, at the same time as confirming that arguments to Halts represent
> a finite computation. This is 100% in line with his prior posts about
> re-defining the terms involved in the problem, AKA, ignoring the
> problem.
>
> He has always been delightfully clear about this nonsense. False is
> declared the correct answer for some halting computations because a
> related computation (the one that "would not halt were it not halted")
> justifies it. Early on, he was even more clear. False is correct
> because of what happens when the Needs_To_Be_aborted line is commented
> out. I suspect he thought that was too crude, so the verbal gymnastics
> started.
>
> (His is also a liar in that he told Mike Terry, point blank, that Halts
> always returns, and always with the same value when given the same
> arguments, but then he told me that Halts does not always return a value
> at all, but I don't think that trick is actually being used. I can't
> say, because all the detail are hidden from us.)
>
>> This impies also that Halts isn't a Compuation either.
>
> I was hoping you could say whether the trace shows recursive calls or
> not rather then opening up the what is a computation on a messy system
> like an x86!
>
> If the trace shows recursive calls, then it doesn't comport with what he
> said about Halts. If it shows the correct nested simulation, then it
> will either just confirm what Halts returns or it will show he was lying
> about that. And if he ever publishes a trace of the key computation
> (H_Hat(H_Hat)) that will either show up some other lies or it will
> confirm that Halts is indeed returning the wrong answer -- the answer PO
> declares to be the right one.
>
The nested simulations are not invocations that must return they are
data that is being processed by the halt decider.
_H_Hat()
[00000b1f](01) 55 push ebp
[00000b20](02) 8bec mov ebp,esp
[00000b22](01) 51 push ecx
[00000b23](03) 8b4508 mov eax,[ebp+08]
[00000b26](01) 50 push eax
[00000b27](03) 8b4d08 mov ecx,[ebp+08]
[00000b2a](01) 51 push ecx
[00000b2b](05) e82ffeffff call 0000095f
[00000b30](03) 83c408 add esp,+08
[00000b33](03) 8945fc mov [ebp-04],eax
[00000b36](04) 837dfc00 cmp dword [ebp-04],+00
[00000b3a](02) 7402 jz 00000b3e
[00000b3c](02) ebfe jmp 00000b3c
[00000b3e](02) 8be5 mov esp,ebp
[00000b40](01) 5d pop ebp
[00000b41](01) c3 ret
Size in bytes:(0035) [00000b41]
_main()
[00000b4f](01) 55 push ebp
[00000b50](02) 8bec mov ebp,esp
[00000b52](01) 51 push ecx
[00000b53](05) 681f0b0000 push 00000b1f
[00000b58](05) 681f0b0000 push 00000b1f
[00000b5d](05) e8fdfdffff call 0000095f
[00000b62](03) 83c408 add esp,+08
[00000b65](03) 8945fc mov [ebp-04],eax
[00000b68](03) 8b45fc mov eax,[ebp-04]
[00000b6b](01) 50 push eax
[00000b6c](05) 682b030000 push 0000032b
[00000b71](05) e8e9f7ffff call 0000035f
[00000b76](03) 83c408 add esp,+08
[00000b79](02) 33c0 xor eax,eax
[00000b7b](02) 8be5 mov esp,ebp
[00000b7d](01) 5d pop ebp
[00000b7e](01) c3 ret
Size in bytes:(0048) [00000b7e]
Columns
(1) Machine address of instruction
(2) Machine address of top of stack
(3) Value of top of stack after instruction executed
(4) Number of bytes of machine code
(5) Machine language bytes
(6) Assembly language text
...[00000b4f][00101542][00000000](01) 55 push ebp
...[00000b50][00101542][00000000](02) 8bec mov ebp,esp
...[00000b52][0010153e][00000000](01) 51 push ecx
...[00000b53][0010153a][00000b1f](05) 681f0b0000 push 00000b1f
...[00000b58][00101536][00000b1f](05) 681f0b0000 push 00000b1f
...[00000b5d][00101532][00000b62](05) e8fdfdffff call 0000095f
Begin Local Halt Decider Simulation at Machine Address:b1f
...[00000b1f][002115e2][002115e6](01) 55 push ebp
...[00000b20][002115e2][002115e6](02) 8bec mov ebp,esp
...[00000b22][002115de][002015b2](01) 51 push ecx
...[00000b23][002115de][002015b2](03) 8b4508 mov
eax,[ebp+08]
...[00000b26][002115da][00000b1f](01) 50 push eax
...[00000b27][002115da][00000b1f](03) 8b4d08 mov
ecx,[ebp+08]
...[00000b2a][002115d6][00000b1f](01) 51 push ecx
...[00000b2b][002115d2][00000b30](05) e82ffeffff call 0000095f
The above eight instructions repeat
...[00000b1f][0025c00a][0025c00e](01) 55 push ebp
...[00000b20][0025c00a][0025c00e](02) 8bec mov ebp,esp
...[00000b22][0025c006][0024bfda](01) 51 push ecx
...[00000b23][0025c006][0024bfda](03) 8b4508 mov
eax,[ebp+08]
...[00000b26][0025c002][00000b1f](01) 50 push eax
...[00000b27][0025c002][00000b1f](03) 8b4d08 mov
ecx,[ebp+08]
...[00000b2a][0025bffe][00000b1f](01) 51 push ecx
...[00000b2b][0025bffa][00000b30](05) e82ffeffff call 0000095f
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
Infinite recursion detection criteria has been met
...[00000b62][0010153e][00000000](03) 83c408 add esp,+08
...[00000b65][0010153e][00000000](03) 8945fc mov
[ebp-04],eax
...[00000b68][0010153e][00000000](03) 8b45fc mov
eax,[ebp-04]
...[00000b6b][0010153a][00000000](01) 50 push eax
...[00000b6c][00101536][0000032b](05) 682b030000 push 0000032b
...[00000b71][00101532][00000b76](05) e8e9f7ffff call 0000035f
Input_Would_Halt = 0
...[00000b76][0010153e][00000000](03) 83c408 add esp,+08
...[00000b79][0010153e][00000000](02) 33c0 xor eax,eax
...[00000b7b][00101542][00000000](02) 8be5 mov esp,ebp
...[00000b7d][00101546][00100000](01) 5d pop ebp
...[00000b7e][0010154a][00000080](01) c3 ret
Number_of_User_Instructions(33)
Number of Instructions Executed(26560)
All calls from H_Hat() to Halts() match the [Infinite Recursion] dynamic
behavior pattern.
If the execution trace of H_Hat() by function Halts() shows:
(1) Function Halts() is called twice in sequence from the same machine
address of H_Hat().
(2) With the same parameters to Halts().
(3) With no conditional branch or indexed jump instructions in H_Hat().
(4) With no function call returns from Halts().
then the function call from H_Hat() to Halts() is infinitely recursive.
It is ridiculously simple to see that H_Hat() does match the [Infinite
Recursion] dynamic behavior pattern of non halting behavior. That you
continue to deny this seems utterly foolish.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-03 10:34 -0400 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <JRTjI.418431$nn2.47149@fx48.iad> |
| In reply to | #32616 |
On 5/3/21 10:06 AM, olcott wrote:
> On 5/3/2021 7:43 AM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> On 5/2/21 7:53 PM, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its
>>>>>>>>>>>>> otherwise
>>>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>>>
>>>>>>>>>>>> This is just a silly word game. What a computation would do
>>>>>>>>>>>> "otherwise"
>>>>>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not
>>>>>>>>>>>> matter how or
>>>>>>>>>>>> why. It is a finite computation, and should be reported as
>>>>>>>>>>>> such.
>>>>>>>>>>>
>>>>>>>>>>> So in other words you believe that it is ridiculous for
>>>>>>>>>>> anyone to ever
>>>>>>>>>>> consider defining a partial halt decider because everyone
>>>>>>>>>>> agrees that
>>>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>>>
>>>>>>>>>> No. I am saying that your wording is silly because it
>>>>>>>>>> attempts to
>>>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>>>
>>>>>>>> I see you don't dispute these facts.
>>>>>>
>>>>>> Good to see these facts confirmed by you once again. If you dispute
>>>>>> that you justify giving the wrong answer using another related
>>>>>> computation, all you need to do is say so (and correct the record
>>>>>> where
>>>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>>>> denote a finite computation).
>>>>>>
>>>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>>>
>>>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the
>>>>>>>> real one,
>>>>>>>> not the one you posted recently to poison the well)? It calls no
>>>>>>>> functions that call H_Hat. In the world of C and x86 code, that
>>>>>>>> means
>>>>>>>> it is not recursive at all.
>>>>>>
>>>>>>>> You ignored the key facts I put to you. These were facts that
>>>>>>>> you told
>>>>>>>> me so you are stuck with them until you correct the record.
>>>>>>>
>>>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>>>> above criteria of infinite recursion, you can dodge this fact but
>>>>>>> you
>>>>>>> cannot correctly refute this fact.
>>>>>>
>>>>>> I am not dodging it -- I am telling you it's a lie. I started out
>>>>>> being
>>>>>> polite and technical, but it amounts to the same thing: if the trace
>>>>>> shows recursion, it is a fake. The only clue you have given us at to
>>>>>> what Halts does made it plain that there is no recursive call, so the
>>>>>> trace you show is, as far anyone can tell, a fiction, a lie,
>>>>>> published
>>>>>> in order to be able to show /something/ when you dare not show the
>>>>>> code.
>>>>>> If the trace shows a recursive call, it does not comport with what
>>>>>> you
>>>>>> have published about Halts and that makes one or other of those (the
>>>>>> sketch of Halts or the trace) a plain deception.
>>>>>
>>>>> Actually, I am not sure I would call it a 'lie' but just a very
>>>>> different model of reality. From what I can infer from what we are
>>>>> told,
>>>>> x86utm is designed as a simulator/halt decider designed to handle
>>>>> systems with this sort of nested simulations.
>>>>>
>>>>> Halts is not really a 'function' in the normal sense, but an entry
>>>>> point
>>>>> into the simulator that converts the call to it to simulate/decide
>>>>> for a
>>>>> provided input into a real 'simulated' call with some book keeping.
>>>>
>>>> The best information we have about Halts (as far as I know) is a sketch
>>>> showing a loop that single-steps a simulation and a function call that
>>>> assesses whether to end the loop:
>>>>
>>>> bool Halts(u32 P, u32 I)
>>>> {
>>>> bool Halted = false;
>>>> bool Aborted = false;
>>>> while (!Halted && !Aborted)
>>>> {
>>>> Halted = DebugStep(P, I);
>>>> Aborted = Needs_To_Be_Aborted();
>>>> }
>>>> return !Aborted;
>>>> }
>>>>
>>>> If the trace shows a recursive call, I'd call that a lie. Something is
>>>> not as we've been led to believe.
>>>>
>>>> Mind you, I refuse to look at the trace, so I am going by what PO says
>>>> about it. Have I misunderstood him? Does it not show Halts(H_Hat,
>>>> H_Hat) making recursive calls?
>>>>
>>>
>>> Yes, he has provided that sketch for Halts, which actually implies if
>>> you think about what he seems to be doing that at least DebugStep isn't
>>> a computation, but an access to the bigger emulator with a lot of hidden
>>> state.
>>>
>>> It CAN'T be a simple computation, as something needs to be keeping track
>>> of each step, and Needs_To_Be_aborted() doesn't have anything to make
>>> its decision on.
>>
>> Of course it has state. I think this concern about what is a simple
>> computation is a side issue. This was posted in reply to a challenge of
>> mine to write a function F(p, i) that returns true if p(i) halts and
>> false otherwise. All I said was that I would provide the confounding
>> case.
>>
>> It does not matter how many side-effects Halts has, or what state it
>> uses or if it trawls the Internet for clues. It is possible to come up
>> with any number of tricks that can get round the usual construction, but
>> it is always possible to generate a confounding case that defeats them.
>> Of course, to do that in the face of the most cunning opponent would
>> require access to the real source code, and not a sketch.
>>
>> But PO is not cunning, he is just silly. He was prepared to confirm
>> that, however it does it, Halts(Confound_Halts, Confound_Halts) returns
>> false, at the same time as confirming that arguments to Halts represent
>> a finite computation. This is 100% in line with his prior posts about
>> re-defining the terms involved in the problem, AKA, ignoring the
>> problem.
>>
>> He has always been delightfully clear about this nonsense. False is
>> declared the correct answer for some halting computations because a
>> related computation (the one that "would not halt were it not halted")
>> justifies it. Early on, he was even more clear. False is correct
>> because of what happens when the Needs_To_Be_aborted line is commented
>> out. I suspect he thought that was too crude, so the verbal gymnastics
>> started.
>>
>> (His is also a liar in that he told Mike Terry, point blank, that Halts
>> always returns, and always with the same value when given the same
>> arguments, but then he told me that Halts does not always return a value
>> at all, but I don't think that trick is actually being used. I can't
>> say, because all the detail are hidden from us.)
>>
>>> This impies also that Halts isn't a Compuation either.
>>
>> I was hoping you could say whether the trace shows recursive calls or
>> not rather then opening up the what is a computation on a messy system
>> like an x86!
>>
>> If the trace shows recursive calls, then it doesn't comport with what he
>> said about Halts. If it shows the correct nested simulation, then it
>> will either just confirm what Halts returns or it will show he was lying
>> about that. And if he ever publishes a trace of the key computation
>> (H_Hat(H_Hat)) that will either show up some other lies or it will
>> confirm that Halts is indeed returning the wrong answer -- the answer PO
>> declares to be the right one.
>>
>
> The nested simulations are not invocations that must return they are
> data that is being processed by the halt decider.
Then why do you trace them as if they were?
>
> _H_Hat()
> [00000b1f](01) 55 push ebp
> [00000b20](02) 8bec mov ebp,esp
> [00000b22](01) 51 push ecx
> [00000b23](03) 8b4508 mov eax,[ebp+08]
> [00000b26](01) 50 push eax
> [00000b27](03) 8b4d08 mov ecx,[ebp+08]
> [00000b2a](01) 51 push ecx
> [00000b2b](05) e82ffeffff call 0000095f
> [00000b30](03) 83c408 add esp,+08
> [00000b33](03) 8945fc mov [ebp-04],eax
> [00000b36](04) 837dfc00 cmp dword [ebp-04],+00
> [00000b3a](02) 7402 jz 00000b3e
> [00000b3c](02) ebfe jmp 00000b3c
> [00000b3e](02) 8be5 mov esp,ebp
> [00000b40](01) 5d pop ebp
> [00000b41](01) c3 ret
> Size in bytes:(0035) [00000b41]
>
> _main()
> [00000b4f](01) 55 push ebp
> [00000b50](02) 8bec mov ebp,esp
> [00000b52](01) 51 push ecx
> [00000b53](05) 681f0b0000 push 00000b1f
> [00000b58](05) 681f0b0000 push 00000b1f
> [00000b5d](05) e8fdfdffff call 0000095f
> [00000b62](03) 83c408 add esp,+08
> [00000b65](03) 8945fc mov [ebp-04],eax
> [00000b68](03) 8b45fc mov eax,[ebp-04]
> [00000b6b](01) 50 push eax
> [00000b6c](05) 682b030000 push 0000032b
> [00000b71](05) e8e9f7ffff call 0000035f
> [00000b76](03) 83c408 add esp,+08
> [00000b79](02) 33c0 xor eax,eax
> [00000b7b](02) 8be5 mov esp,ebp
> [00000b7d](01) 5d pop ebp
> [00000b7e](01) c3 ret
> Size in bytes:(0048) [00000b7e]
>
> Columns
> (1) Machine address of instruction
> (2) Machine address of top of stack
> (3) Value of top of stack after instruction executed
> (4) Number of bytes of machine code
> (5) Machine language bytes
> (6) Assembly language text
>
> ...[00000b4f][00101542][00000000](01) 55 push ebp
> ...[00000b50][00101542][00000000](02) 8bec mov ebp,esp
> ...[00000b52][0010153e][00000000](01) 51 push ecx
> ...[00000b53][0010153a][00000b1f](05) 681f0b0000 push
> 00000b1f
> ...[00000b58][00101536][00000b1f](05) 681f0b0000 push
> 00000b1f
> ...[00000b5d][00101532][00000b62](05) e8fdfdffff call
> 0000095f
>
> Begin Local Halt Decider Simulation at Machine Address:b1f
> ...[00000b1f][002115e2][002115e6](01) 55 push ebp
> ...[00000b20][002115e2][002115e6](02) 8bec mov ebp,esp
> ...[00000b22][002115de][002015b2](01) 51 push ecx
> ...[00000b23][002115de][002015b2](03) 8b4508 mov
> eax,[ebp+08]
> ...[00000b26][002115da][00000b1f](01) 50 push eax
> ...[00000b27][002115da][00000b1f](03) 8b4d08 mov
> ecx,[ebp+08]
> ...[00000b2a][002115d6][00000b1f](01) 51 push ecx
> ...[00000b2b][002115d2][00000b30](05) e82ffeffff call
> 0000095f
> The above eight instructions repeat
>
> ...[00000b1f][0025c00a][0025c00e](01) 55 push ebp
> ...[00000b20][0025c00a][0025c00e](02) 8bec mov ebp,esp
> ...[00000b22][0025c006][0024bfda](01) 51 push ecx
> ...[00000b23][0025c006][0024bfda](03) 8b4508 mov
> eax,[ebp+08]
> ...[00000b26][0025c002][00000b1f](01) 50 push eax
> ...[00000b27][0025c002][00000b1f](03) 8b4d08 mov
> ecx,[ebp+08]
> ...[00000b2a][0025bffe][00000b1f](01) 51 push ecx
> ...[00000b2b][0025bffa][00000b30](05) e82ffeffff call
> 0000095f
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> Infinite recursion detection criteria has been met
>
> ...[00000b62][0010153e][00000000](03) 83c408 add esp,+08
> ...[00000b65][0010153e][00000000](03) 8945fc mov
> [ebp-04],eax
> ...[00000b68][0010153e][00000000](03) 8b45fc mov
> eax,[ebp-04]
> ...[00000b6b][0010153a][00000000](01) 50 push eax
> ...[00000b6c][00101536][0000032b](05) 682b030000 push
> 0000032b
> ...[00000b71][00101532][00000b76](05) e8e9f7ffff call
> 0000035f
> Input_Would_Halt = 0
> ...[00000b76][0010153e][00000000](03) 83c408 add esp,+08
> ...[00000b79][0010153e][00000000](02) 33c0 xor eax,eax
> ...[00000b7b][00101542][00000000](02) 8be5 mov esp,ebp
> ...[00000b7d][00101546][00100000](01) 5d pop ebp
> ...[00000b7e][0010154a][00000080](01) c3 ret
> Number_of_User_Instructions(33)
> Number of Instructions Executed(26560)
>
> All calls from H_Hat() to Halts() match the [Infinite Recursion] dynamic
> behavior pattern.
> If the execution trace of H_Hat() by function Halts() shows:
> (1) Function Halts() is called twice in sequence from the same machine
> address of H_Hat().
> (2) With the same parameters to Halts().
> (3) With no conditional branch or indexed jump instructions in H_Hat().
> (4) With no function call returns from Halts().
> then the function call from H_Hat() to Halts() is infinitely recursive.
>
> It is ridiculously simple to see that H_Hat() does match the [Infinite
> Recursion] dynamic behavior pattern of non halting behavior. That you
> continue to deny this seems utterly foolish.
>
And that rule is flawed, as the conditionals inside the 'call' to Halts
within H_Hat are PART of the Computation of H_Hat, and thus its decision
(or ability to decide) is part of H_Hat, which the outer Halts does not
take into account.
Your trace is flawed, as you don't trace the simulation of the code of
Halts, but switch to the trace that it is simulating. That is an
incorrect operation.
The outer trace from Halts should show a tracing of what the call to
Halts in H_Hat actually does, as THAT is what the outer Halts should be
simulating. By 'taking over' the simulation it has conflated its own
simulation with that of the code inside H_Hat.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-04 00:58 +0100 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <87y2cv4bfl.fsf@bsb.me.uk> |
| In reply to | #32616 |
olcott <NoOne@NoWhere.com> writes: > It is ridiculously simple to see that H_Hat() does match the [Infinite > Recursion] dynamic behavior pattern of non halting behavior. That you > continue to deny this seems utterly foolish. You are very confused about what other people think. I would never comment on whether some code I have never seen conforms to some pattern you have given a silly name to. Especially as you have described this pattern using, apparently, the wrong words. You talk about recursive calls and I believe that to be, at best, a misuse of language. I know that halts must detect /something/ that it can use to give the wrong answer but I don't really care what it is detecting (and I certainly don't care what you've decided to call it) because it can't justify the wrong answer: (a) Halts(H_Hat, H_Hat) is false, but (b) the arguments to false represent and finite computation. You simply declare the wrong answer to be the right one. Simples! -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 10:12 -0500 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <2Y-dneetWMrS-Qz9nZ2dnUU7-ROdnZ2d@giganews.com> |
| In reply to | #32660 |
On 5/3/2021 6:58 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> It is ridiculously simple to see that H_Hat() does match the [Infinite >> Recursion] dynamic behavior pattern of non halting behavior. That you >> continue to deny this seems utterly foolish. > > You are very confused about what other people think. I would never > comment on whether some code I have never seen conforms to some pattern > you have given a silly name to. Especially as you have described this > pattern using, apparently, the wrong words. You talk about recursive > calls and I believe that to be, at best, a misuse of language. > > I know that halts must detect /something/ that it can use to give the > wrong answer but I don't really care what it is detecting (and I > certainly don't care what you've decided to call it) because it can't > justify the wrong answer: > > (a) Halts(H_Hat, H_Hat) is false, but > (b) the arguments to false represent and finite computation. > > You simply declare the wrong answer to be the right one. Simples! > Do you understand the generic idea that non halting behavior could be detected when this behavior matches a non-halting dynamic behavior pattern? -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-04 21:57 +0100 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <87tuni2p5j.fsf@bsb.me.uk> |
| In reply to | #32671 |
olcott <NoOne@NoWhere.com> writes: > On 5/3/2021 6:58 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> It is ridiculously simple to see that H_Hat() does match the [Infinite >>> Recursion] dynamic behavior pattern of non halting behavior. That you >>> continue to deny this seems utterly foolish. >> >> You are very confused about what other people think. I would never >> comment on whether some code I have never seen conforms to some pattern >> you have given a silly name to. Especially as you have described this >> pattern using, apparently, the wrong words. You talk about recursive >> calls and I believe that to be, at best, a misuse of language. >> >> I know that halts must detect /something/ that it can use to give the >> wrong answer but I don't really care what it is detecting (and I >> certainly don't care what you've decided to call it) because it can't >> justify the wrong answer: >> >> (a) Halts(H_Hat, H_Hat) is false, but >> (b) the arguments to false represent and finite computation. >> >> You simply declare the wrong answer to be the right one. Simples! > > Do you understand the generic idea that non halting behavior could be > detected when this behavior matches a non-halting dynamic behavior > pattern? Of course. Do you understand that false is the wrong answer for Halts to give when the arguments to Halts denote a computation that is finite? Try to give as honest and direct an answer as you can. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2021-05-03 11:39 -0600 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <s6pcgd$d21$1@dont-email.me> |
| In reply to | #32614 |
On 5/3/2021 6:43 AM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> On 5/2/21 7:53 PM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>>
>>>>>>>>>>> This is just a silly word game. What a computation would do "otherwise"
>>>>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>>>>>
>>>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>>
>>>>>>>>> No. I am saying that your wording is silly because it attempts to
>>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>>
>>>>>>> I see you don't dispute these facts.
>>>>>
>>>>> Good to see these facts confirmed by you once again. If you dispute
>>>>> that you justify giving the wrong answer using another related
>>>>> computation, all you need to do is say so (and correct the record where
>>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>>> denote a finite computation).
>>>>>
>>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>>
>>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>>>> not the one you posted recently to poison the well)? It calls no
>>>>>>> functions that call H_Hat. In the world of C and x86 code, that means
>>>>>>> it is not recursive at all.
>>>>>
>>>>>>> You ignored the key facts I put to you. These were facts that you told
>>>>>>> me so you are stuck with them until you correct the record.
>>>>>>
>>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>>>> cannot correctly refute this fact.
>>>>>
>>>>> I am not dodging it -- I am telling you it's a lie. I started out being
>>>>> polite and technical, but it amounts to the same thing: if the trace
>>>>> shows recursion, it is a fake. The only clue you have given us at to
>>>>> what Halts does made it plain that there is no recursive call, so the
>>>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>>>> in order to be able to show /something/ when you dare not show the code.
>>>>> If the trace shows a recursive call, it does not comport with what you
>>>>> have published about Halts and that makes one or other of those (the
>>>>> sketch of Halts or the trace) a plain deception.
>>>>
>>>> Actually, I am not sure I would call it a 'lie' but just a very
>>>> different model of reality. From what I can infer from what we are told,
>>>> x86utm is designed as a simulator/halt decider designed to handle
>>>> systems with this sort of nested simulations.
>>>>
>>>> Halts is not really a 'function' in the normal sense, but an entry point
>>>> into the simulator that converts the call to it to simulate/decide for a
>>>> provided input into a real 'simulated' call with some book keeping.
>>>
>>> The best information we have about Halts (as far as I know) is a sketch
>>> showing a loop that single-steps a simulation and a function call that
>>> assesses whether to end the loop:
>>>
>>> bool Halts(u32 P, u32 I)
>>> {
>>> bool Halted = false;
>>> bool Aborted = false;
>>> while (!Halted && !Aborted)
>>> {
>>> Halted = DebugStep(P, I);
>>> Aborted = Needs_To_Be_Aborted();
>>> }
>>> return !Aborted;
>>> }
>>>
>>> If the trace shows a recursive call, I'd call that a lie. Something is
>>> not as we've been led to believe.
>>>
>>> Mind you, I refuse to look at the trace, so I am going by what PO says
>>> about it. Have I misunderstood him? Does it not show Halts(H_Hat,
>>> H_Hat) making recursive calls?
>>>
>>
>> Yes, he has provided that sketch for Halts, which actually implies if
>> you think about what he seems to be doing that at least DebugStep isn't
>> a computation, but an access to the bigger emulator with a lot of hidden
>> state.
>>
>> It CAN'T be a simple computation, as something needs to be keeping track
>> of each step, and Needs_To_Be_aborted() doesn't have anything to make
>> its decision on.
>
> Of course it has state. I think this concern about what is a simple
> computation is a side issue. This was posted in reply to a challenge of
> mine to write a function F(p, i) that returns true if p(i) halts and
> false otherwise. All I said was that I would provide the confounding
> case.
>
> It does not matter how many side-effects Halts has, or what state it
> uses or if it trawls the Internet for clues. It is possible to come up
> with any number of tricks that can get round the usual construction, but
> it is always possible to generate a confounding case that defeats them.
> Of course, to do that in the face of the most cunning opponent would
> require access to the real source code, and not a sketch.
There is a precedent for that need in the world of computer security:
When one wanted to test the vulnerability of supposed secure systems -
usually operating systems - the "crackers" were always given the source
code, etc. It was assumed that any serious opponent - usually an
adversary nation state - would have made covert arrangements to obtain
the same. Trying to develop a reliable crack for a complex black (or
dark grey) box from the outside was recognized early on as a mostly
futile activity.
In the current enterprise the claim is that given an H with a particular
property one can find an application where the claim is false. Since
such a claim is parameterized by H, the definition of H is necessary to
actually state a particular claim. It is quite fortunate that there is a
constructive proof scheme that may be applied to each H to show the
claim is false. If this were not the case, the halting problem might
still be an issue.
> But PO is not cunning, he is just silly. He was prepared to confirm
> that, however it does it, Halts(Confound_Halts, Confound_Halts) returns
> false, at the same time as confirming that arguments to Halts represent
> a finite computation. This is 100% in line with his prior posts about
> re-defining the terms involved in the problem, AKA, ignoring the
> problem.
>
> He has always been delightfully clear about this nonsense. False is
> declared the correct answer for some halting computations because a
> related computation (the one that "would not halt were it not halted")
> justifies it. Early on, he was even more clear. False is correct
> because of what happens when the Needs_To_Be_aborted line is commented
> out. I suspect he thought that was too crude, so the verbal gymnastics
> started.
>
> (His is also a liar in that he told Mike Terry, point blank, that Halts
> always returns, and always with the same value when given the same
> arguments, but then he told me that Halts does not always return a value
> at all, but I don't think that trick is actually being used. I can't
> say, because all the detail are hidden from us.)
>
>> This impies also that Halts isn't a Compuation either.
>
> I was hoping you could say whether the trace shows recursive calls or
> not rather then opening up the what is a computation on a messy system
> like an x86!
>
> If the trace shows recursive calls, then it doesn't comport with what he
> said about Halts. If it shows the correct nested simulation, then it
> will either just confirm what Halts returns or it will show he was lying
> about that. And if he ever publishes a trace of the key computation
> (H_Hat(H_Hat)) that will either show up some other lies or it will
> confirm that Halts is indeed returning the wrong answer -- the answer PO
> declares to be the right one.
--
Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-02 17:41 -0500 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <_f2dnUajsvEUtxL9nZ2dnUU7-cPNnZ2d@giganews.com> |
| In reply to | #32592 |
On 5/2/2021 3:38 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>
>>>>>>> This is just a silly word game. What a computation would do "otherwise"
>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>
>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>
>>>>> No. I am saying that your wording is silly because it attempts to
>>>>> justify the wrong answer using another, different, computation.
>>>>> H_Hat(H_Hat) is finite.
>>>
>>> I see you don't dispute these facts.
>
> Good to see these facts confirmed by you once again. If you dispute
> that you justify giving the wrong answer using another related
> computation, all you need to do is say so (and correct the record where
> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
> denote a finite computation).
>
>>>> The above criteria does correctly decide infinite recursion.
>>>
>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>> not the one you posted recently to poison the well)? It calls no
>>> functions that call H_Hat. In the world of C and x86 code, that means
>>> it is not recursive at all.
>
>>> You ignored the key facts I put to you. These were facts that you told
>>> me so you are stuck with them until you correct the record.
>>
>> The key fact is that every time H_Hat() calls Halts() it meets the
>> above criteria of infinite recursion, you can dodge this fact but you
>> cannot correctly refute this fact.
>
> I am not dodging it -- I am telling you it's a lie.
You can even tell me that it is a lie, what you cannot do is prove that
it is false.
> I started out being
> polite and technical, but it amounts to the same thing: if the trace
> shows recursion, it is a fake.
void H_Hat2(u32 P)
{
u32 Input_Would_Halt = Simulate(P, P);
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat2, (u32)H_Hat2);
}
In other words you are saying that the above is not computationally
equivalent to infinite recursion.
> The only clue you have given us at to
> what Halts does made it plain that there is no recursive call, so the
Computationally equivalent to a recursive call is you insistent on being
so damned (condemned to Hell) nit picky.
> trace you show is, as far anyone can tell, a fiction, a lie, published
It can be very easily verified as necessarily correct on the basis of
the provided disassembled x86 code. The x86 source code proves that
H_Hat() would do exactly what its execution trace shows that it does.
> in order to be able to show /something/ when you dare not show the code.
> If the trace shows a recursive call, it does not comport with what you
> have published about Halts and that makes one or other of those (the
> sketch of Halts or the trace) a plain deception.
>
I need not show the code of Halts(), anyone can understand that it is an
x86 emulator that does correctly match certain dynamic patterns of non
halting behavior on the basis of this paper:
http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-03 00:52 +0100 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <87im407kxf.fsf@bsb.me.uk> |
| In reply to | #32596 |
olcott <NoOne@NoWhere.com> writes:
> On 5/2/2021 3:38 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>
>>>>>>>> This is just a silly word game. What a computation would do "otherwise"
>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>>
>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>
>>>>>> No. I am saying that your wording is silly because it attempts to
>>>>>> justify the wrong answer using another, different, computation.
>>>>>> H_Hat(H_Hat) is finite.
>>>>
>>>> I see you don't dispute these facts.
>>
>> Good to see these facts confirmed by you once again. If you dispute
>> that you justify giving the wrong answer using another related
>> computation, all you need to do is say so (and correct the record where
>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>> denote a finite computation).
I think we can safely assume that you do not want to dispute any of
these facts.
>>>>> The above criteria does correctly decide infinite recursion.
>>>>
>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>> not the one you posted recently to poison the well)? It calls no
>>>> functions that call H_Hat. In the world of C and x86 code, that means
>>>> it is not recursive at all.
>>
>>>> You ignored the key facts I put to you. These were facts that you told
>>>> me so you are stuck with them until you correct the record.
>>>
>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>> above criteria of infinite recursion, you can dodge this fact but you
>>> cannot correctly refute this fact.
>>
>> I am not dodging it -- I am telling you it's a lie.
>
> You can even tell me that it is a lie, what you cannot do is prove
> that it is false.
I don't know what that means. I take what you say about the trace at
face value because I don't want to look at it without knowing what's
being traced. You appear to be suggesting that the trace shows
recursive calls where there should be none. I am happy to be corrected
on this point. Does the trace show infinite nested simulations instead?
>> I started out being
>> polite and technical, but it amounts to the same thing: if the trace
>> shows recursion, it is a fake.
>
> void H_Hat2(u32 P)
> {
> u32 Input_Would_Halt = Simulate(P, P);
> }
>
> int main()
> {
> u32 Input_Would_Halt = Halts((u32)H_Hat2, (u32)H_Hat2);
> }
>
> In other words you are saying that the above is not computationally
> equivalent to infinite recursion.
What a mess. More code missing in action. More odd phrases. My best
guess at what "computationally equivalent to infinite recursion" means
is simply any non-finite computation. So if you will just confirm that
Halts never returns to main, than I can actually agree -- the above is
"computationally equivalent to infinite recursion".
However, that is not my understanding of what one of the mystery
functions does. I understood that Halts /does/ return to main.
>> The only clue you have given us at to
>> what Halts does made it plain that there is no recursive call, so the
>
> Computationally equivalent to a recursive call is you insistent on
> being so damned (condemned to Hell) nit picky.
I know what "computationally equivalent" means but it makes no sense
when joined with "to a recursive call".
I think you are agreeing that there are no recursive calls. But doesn't
the trace show that there are? I thought it did.
By the way, I can also to "big picture" stuff. I don't always nit-pick.
See, for example, the text at the very top where, by not objecting, you
are implicitly agreeing by high-level summary of what you doing.
> I need not show the code of Halts(),
Well you /should/. But I accept that you mustn't in order to keep
stringing people along. After all, it's the chatting you like.
> http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf
That paper clearly says that you are talking about recursive calls. In
other words, that paper uses the language correctly, and I assume the
trace shows recursive calls as well. This suggests that either the
trace is fake or Halts is not at all as you described it last year. Or
maybe the paper uses the wrong words. Something is screwey.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-02 19:34 -0500 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <yqudnQROUq5-2RL9nZ2dnUU7-VnNnZ2d@giganews.com> |
| In reply to | #32598 |
On 5/2/2021 6:52 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 5/2/2021 3:38 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>
>>>>>>>>> This is just a silly word game. What a computation would do "otherwise"
>>>>>>>>> is irrelevant. H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>> why. It is a finite computation, and should be reported as such.
>>>>>>>>
>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>
>>>>>>> No. I am saying that your wording is silly because it attempts to
>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>> H_Hat(H_Hat) is finite.
>>>>>
>>>>> I see you don't dispute these facts.
>>>
>>> Good to see these facts confirmed by you once again. If you dispute
>>> that you justify giving the wrong answer using another related
>>> computation, all you need to do is say so (and correct the record where
>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>> denote a finite computation).
>
> I think we can safely assume that you do not want to dispute any of
> these facts.
>
>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>
>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>> not the one you posted recently to poison the well)? It calls no
>>>>> functions that call H_Hat. In the world of C and x86 code, that means
>>>>> it is not recursive at all.
>>>
>>>>> You ignored the key facts I put to you. These were facts that you told
>>>>> me so you are stuck with them until you correct the record.
>>>>
>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>> cannot correctly refute this fact.
>>>
>>> I am not dodging it -- I am telling you it's a lie.
>>
>> You can even tell me that it is a lie, what you cannot do is prove
>> that it is false.
>
> I don't know what that means. I take what you say about the trace at
> face value because I don't want to look at it without knowing what's
> being traced. You appear to be suggesting that the trace shows
> recursive calls where there should be none. I am happy to be corrected
> on this point. Does the trace show infinite nested simulations instead?
>
Since the halt deciding criteria that matches infinite recursion is
exactly the same as the criteria that matches infinite nested
simulations and infinite nested simulations are computationally
equivalent to infinite recursion I can them both infinite recursion.
The halt decider knows nothing about infinitely nested simulations it
only knows that its infinite recursion dynamic behavior pattern has been
matched.
>>> I started out being
>>> polite and technical, but it amounts to the same thing: if the trace
>>> shows recursion, it is a fake.
>>
>> void H_Hat2(u32 P)
>> {
>> u32 Input_Would_Halt = Simulate(P, P);
>> }
>>
>> int main()
>> {
>> u32 Input_Would_Halt = Halts((u32)H_Hat2, (u32)H_Hat2);
>> }
>>
>> In other words you are saying that the above is not computationally
>> equivalent to infinite recursion.
>
> What a mess. More code missing in action. More odd phrases. My best
> guess at what "computationally equivalent to infinite recursion" means
> is simply any non-finite computation.
It is a specific dynamic behavior pattern that the halt decider has
matched. It only distinguishes between infinite recursion and infinite
loops.
> So if you will just confirm that
> Halts never returns to main, than I can actually agree -- the above is
> "computationally equivalent to infinite recursion".
>
> However, that is not my understanding of what one of the mystery
> functions does. I understood that Halts /does/ return to main.
>
>>> The only clue you have given us at to
>>> what Halts does made it plain that there is no recursive call, so the
>>
>> Computationally equivalent to a recursive call is you insistent on
>> being so damned (condemned to Hell) nit picky.
>
> I know what "computationally equivalent" means but it makes no sense
> when joined with "to a recursive call".
>
Infinite recursion and infinite nested simulations demonstrate the exact
same dynamic behavior pattern.
> I think you are agreeing that there are no recursive calls. But doesn't
> the trace show that there are? I thought it did.
>
Infinite recursion and infinite nested simulations demonstrate the exact
same (infinite execution) dynamic behavior pattern.
> By the way, I can also to "big picture" stuff. I don't always nit-pick.
> See, for example, the text at the very top where, by not objecting, you
> are implicitly agreeing by high-level summary of what you doing.
>
>> I need not show the code of Halts(),
>
> Well you /should/. But I accept that you mustn't in order to keep
> stringing people along. After all, it's the chatting you like.
>
>> http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf
>
> That paper clearly says that you are talking about recursive calls. In
> other words, that paper uses the language correctly, and I assume the
> trace shows recursive calls as well. This suggests that either the
> trace is fake or Halts is not at all as you described it last year. Or
> maybe the paper uses the wrong words. Something is screwey.
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-02 20:49 -0400 |
| Subject | Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ] |
| Message-ID | <8MHjI.345907$nn2.134064@fx48.iad> |
| In reply to | #32600 |
On 5/2/21 8:34 PM, olcott wrote: > Since the halt deciding criteria that matches infinite recursion is > exactly the same as the criteria that matches infinite nested > simulations and infinite nested simulations are computationally > equivalent to infinite recursion I can them both infinite recursion. You mean the same criteria that applies to ANY computation, does the Computation actually halt or not? (And H_Hat halts). > > The halt decider knows nothing about infinitely nested simulations it > only knows that its infinite recursion dynamic behavior pattern has been > matched. It should. It obviously isn't simulating the simulator. This also point out the error in building the machine of NOT making a copy of Halts when H_Hat was built. As I mentioned elsewhere, my guess is that Halts isn't actually a real computation in implementation, thus showing that it isn't really a Turing Machine Equivalent on its own, thus can't qualify as a true Halt Decider.
[toc] | [prev] | [next] | [standalone]
Page 2 of 5 — ← Prev page 1 [2] 3 4 5 Next page →
Back to top | Article view | comp.theory
csiph-web