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 3 of 5 — ← Prev page 1 2 [3] 4 5 Next page →
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-03 17:23 +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 | <87sg336b2g.fsf@bsb.me.uk> |
| In reply to | #32600 |
olcott <NoOne@NoWhere.com> writes:
> 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.
All the smoke you are trying to blow below can not detract from this end
result. You are stupidly trying to get away with the wrong answer.
>>>>>>> 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.
I /think/ this means that you now know you used the wrong words but you
were not trying to mislead anyone. Is that about it?
>>>> 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.
In the case that matters, Halts(H_Hat, H_Hat), (when Halts gets the
answer wrong) Halts again detects something "computationally equivalent
to infinite recursion" but the arguments to Halts denote a finite
computation do they not?
What new level of crazy language is this?
>>> 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.
Don't be silly. They demonstrate quite different behaviours. You
misuse "exact" like this all the time. What you mean is that they are
enough alike that you forgot to use the right words. Or maybe you used
the wrong words deliberately with the intent of misleading?
>> 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.
So you won't say if the trace shows actual calls? You would be sure to
point it out if it didn't, so I think it is safe to assume it does!
>>> 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.
**crickets**
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-03 14:00 -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 | <o6SdnYYJuvqG1Q39nZ2dnUU7-IvNnZ2d@giganews.com> |
| In reply to | #32644 |
On 5/3/2021 11:23 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> 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.
>
> All the smoke you are trying to blow below can not detract from this end
> result. You are stupidly trying to get away with the wrong answer.
>
>>>>>>>> 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.
>
> I /think/ this means that you now know you used the wrong words but you
> were not trying to mislead anyone. Is that about it?
I always speak in terms of the essential gist of things not paying
attention to the microscopic details.
Because it is ridiculously obvious that infinitely nested simulation has
computationally identical halting behavior to infinite recursion and
both non halting behavior patterns are identical and the halt decider
does not care and does not know the difference I named the single
dynamic behavior pattern the [infinite recursion] dynamic behavior pattern.
>>>>> 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.
>
> In the case that matters, Halts(H_Hat, H_Hat), (when Halts gets the
> answer wrong) Halts again detects something "computationally equivalent
> to infinite recursion" but the arguments to Halts denote a finite
> computation do they not?
>
<sarcasm>
Yes of course every knows that all infinite loops automatically stop at
the very first iteration that is why they are called infinite loops.
"Infinite" in this context means {a single iteration}. </sarcasm>
> What new level of crazy language is this?
>
>>>> 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.
>
> Don't be silly.
They demonstrate this exact same behavior pattern
If the execution trace of function Y() shows:
function X() is called twice in sequence from the same machine address
of Y()
with the same parameters to X()
with no conditional branch or indexed jump instructions in Y()
with no function call returns from X()
then the function call from Y() to X() is infinitely recursive
(or a infinitely nested simulation).
> They demonstrate quite different behaviours. You
> misuse "exact" like this all the time. What you mean is that they are
> enough alike that you forgot to use the right words. Or maybe you used
> the wrong words deliberately with the intent of misleading?
>
>>> 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.
>
> So you won't say if the trace shows actual calls? You would be sure to
> point it out if it didn't, so I think it is safe to assume it does!
I have shown the actual calls many hundreds of times over the last six
months.
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
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 | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-03 15:23 -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 | <P4YjI.24922$zx1.9827@fx20.iad> |
| In reply to | #32653 |
On 5/3/21 3:00 PM, olcott wrote:
> On 5/3/2021 11:23 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> 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.
>>
>> All the smoke you are trying to blow below can not detract from this end
>> result. You are stupidly trying to get away with the wrong answer.
>>
>>>>>>>>> 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.
>>
>> I /think/ this means that you now know you used the wrong words but you
>> were not trying to mislead anyone. Is that about it?
>
> I always speak in terms of the essential gist of things not paying
> attention to the microscopic details.
>
> Because it is ridiculously obvious that infinitely nested simulation has
> computationally identical halting behavior to infinite recursion and
> both non halting behavior patterns are identical and the halt decider
> does not care and does not know the difference I named the single
> dynamic behavior pattern the [infinite recursion] dynamic behavior pattern.
The issue is you ignore some 'detail' that actually IS important.
Like the fact that the subroutine 'Halts' when called by H_Hat is PART
OF H_HAT, and that its decision to stop simulating the input it was
given does NOT make H_Hat an 'infinite recursion' but is in fact the
decision that makes H_Hat finite. That seems to be a 'detail' that you
over look.
This comes about because of a lot of other 'details' that you want to
gloss over.
You also seem blind to the fact that H_Hat when actually run does stop,
so it must be a Halting Computation by the normal definition.
>
>>>>>> 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.
>>
>> In the case that matters, Halts(H_Hat, H_Hat), (when Halts gets the
>> answer wrong) Halts again detects something "computationally equivalent
>> to infinite recursion" but the arguments to Halts denote a finite
>> computation do they not?
>>
>
> <sarcasm>
> Yes of course every knows that all infinite loops automatically stop at
> the very first iteration that is why they are called infinite loops.
> "Infinite" in this context means {a single iteration}. </sarcasm>
But it isn't infinite if the code in the loop stops it, is it?
Just like for(int i=0; i < 5; i++) continue;
isn't an infinite loop, neither is H_Hat, as the call to Halts with in
stops the otherwise potentially infinite loop.
Only your insistence that somehow Halts isn't part of H_Hat or
conflating the instance of Halts that is deciding at the top level on
H_hat with the copy within it get you into your confused state of mind.
>
>
>> What new level of crazy language is this?
>>
>>>>> 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.
>>
>> Don't be silly.
>
> They demonstrate this exact same behavior pattern
>
> If the execution trace of function Y() shows:
> function X() is called twice in sequence from the same machine address
> of Y()
> with the same parameters to X()
> with no conditional branch or indexed jump instructions in Y()
> with no function call returns from X()
> then the function call from Y() to X() is infinitely recursive
> (or a infinitely nested simulation).
But when Y calls X, then any decision within X is part of the
computation of Y, so if it can make a difference it counts.
Also, in your example, if X is really called and really IS a
computation, then X can't terminate the looping either. It is only that
this call sequence isn't what is really happening that you can start to
try to use it as an argument.
Basically, this is a smoke screen.
>
>> They demonstrate quite different behaviours. You
>> misuse "exact" like this all the time. What you mean is that they are
>> enough alike that you forgot to use the right words. Or maybe you used
>> the wrong words deliberately with the intent of misleading?
>>
>>>> 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.
>>
>> So you won't say if the trace shows actual calls? You would be sure to
>> point it out if it didn't, so I think it is safe to assume it does!
>
> I have shown the actual calls many hundreds of times over the last six
> months.
>
> 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
>
>
> http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf
>
>
>
>
But here is the fuller trace you posted that shows that H_Hat does stop
if run as the actual machine:
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)
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 09:53 -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 | <Ec6dnXIC1JZSwgz9nZ2dnUU7-X3NnZ2d@giganews.com> |
| In reply to | #32655 |
On 5/3/2021 2:23 PM, Richard Damon wrote: > On 5/3/21 3:00 PM, olcott wrote: >> On 5/3/2021 11:23 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> 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. >>> >>> All the smoke you are trying to blow below can not detract from this end >>> result. You are stupidly trying to get away with the wrong answer. >>> >>>>>>>>>> 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. >>> >>> I /think/ this means that you now know you used the wrong words but you >>> were not trying to mislead anyone. Is that about it? >> >> I always speak in terms of the essential gist of things not paying >> attention to the microscopic details. >> >> Because it is ridiculously obvious that infinitely nested simulation has >> computationally identical halting behavior to infinite recursion and >> both non halting behavior patterns are identical and the halt decider >> does not care and does not know the difference I named the single >> dynamic behavior pattern the [infinite recursion] dynamic behavior pattern. > > The issue is you ignore some 'detail' that actually IS important. > > Like the fact that the subroutine 'Halts' when called by H_Hat is PART > OF H_HAT, and that its decision to stop simulating the input it was > given does NOT make H_Hat an 'infinite recursion' An infinite loop is correctly decided to specify non halting behavior on the basis that it matches the [infinite loop] dynamic behavior pattern. The fact that it does halt because the halt decider forced it to halt does not change this. The fact that H_Hat() always matches the [infinite recursion]** dynamic behavior pattern (when it is executed with itself as input) is what makes the halt decider's decision correct. The fact that it does halt because the halt decider forced it to halt does not change this. ** Also applies to infinitely nested simulations. -- 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-04 11:21 -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 | <RDdkI.174690$N_4.168228@fx36.iad> |
| In reply to | #32667 |
On 5/4/21 10:53 AM, olcott wrote: > On 5/3/2021 2:23 PM, Richard Damon wrote: >> On 5/3/21 3:00 PM, olcott wrote: >>> On 5/3/2021 11:23 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> 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. >>>> >>>> All the smoke you are trying to blow below can not detract from this >>>> end >>>> result. You are stupidly trying to get away with the wrong answer. >>>> >>>>>>>>>>> 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. >>>> >>>> I /think/ this means that you now know you used the wrong words but you >>>> were not trying to mislead anyone. Is that about it? >>> >>> I always speak in terms of the essential gist of things not paying >>> attention to the microscopic details. >>> >>> Because it is ridiculously obvious that infinitely nested simulation has >>> computationally identical halting behavior to infinite recursion and >>> both non halting behavior patterns are identical and the halt decider >>> does not care and does not know the difference I named the single >>> dynamic behavior pattern the [infinite recursion] dynamic behavior >>> pattern. >> >> The issue is you ignore some 'detail' that actually IS important. >> >> Like the fact that the subroutine 'Halts' when called by H_Hat is PART >> OF H_HAT, and that its decision to stop simulating the input it was >> given does NOT make H_Hat an 'infinite recursion' > > > An infinite loop is correctly decided to specify non halting behavior on > the basis that it matches the [infinite loop] dynamic behavior pattern. > The fact that it does halt because the halt decider forced it to halt > does not change this. > > The fact that H_Hat() always matches the [infinite recursion]** dynamic > behavior pattern (when it is executed with itself as input) is what > makes the halt decider's decision correct. The fact that it does halt > because the halt decider forced it to halt does not change this. > > ** Also applies to infinitely nested simulations. > If you say H_Hat matches your infinite recursion pattern, your pattern is WRONG. This is a rule you are making up yourself, so has no proof of being correct. Simple Proof: 1) Halts is stipulated to meet the requirements of a Halt Decider for Computation Theory, as used in the proof of Linz and Sipser. 2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat) when asked directly. 3) H_Hat is stipulated to be built like Linz or Sipser, in that it will halt when the Halt decider it is built on decides H_Hat’s input is non-Halting on itself. 4) 1 Means that Halts is a Computation, and will always return the same answer (or never return an answer) for a given input. 5) H_Hat(H_Hat) when run as a Machine will perform the Computation Halts(H_Hat, H_Hat) 6) by 4 and 2, this means that Halts will return the decision on non-halting to H_Hat 7) By 3, this means that H_Hat will Halt. Show what is wrong with that. Any logic that says H_Hat(H_Hat) is a non-halting Computation must be wrong, or based on an inconsistent logic system, by definition, unless you can show an actual logic error with the above proof. If you disagree with stipulation 1 or 3, then Halts does not meet the requirements of being a Halt Decider, and thus your proof means nothing. If you disagree with stipulation 2, then we can rework the proof to show that it is still is wrong, and you have been blathering for the past years.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 10:28 -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 | <cN-dnQ66K5659Qz9nZ2dnUU7-cvNnZ2d@giganews.com> |
| In reply to | #32672 |
On 5/4/2021 10:21 AM, Richard Damon wrote: > On 5/4/21 10:53 AM, olcott wrote: >> On 5/3/2021 2:23 PM, Richard Damon wrote: >>> On 5/3/21 3:00 PM, olcott wrote: >>>> On 5/3/2021 11:23 AM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> 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. >>>>> >>>>> All the smoke you are trying to blow below can not detract from this >>>>> end >>>>> result. You are stupidly trying to get away with the wrong answer. >>>>> >>>>>>>>>>>> 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. >>>>> >>>>> I /think/ this means that you now know you used the wrong words but you >>>>> were not trying to mislead anyone. Is that about it? >>>> >>>> I always speak in terms of the essential gist of things not paying >>>> attention to the microscopic details. >>>> >>>> Because it is ridiculously obvious that infinitely nested simulation has >>>> computationally identical halting behavior to infinite recursion and >>>> both non halting behavior patterns are identical and the halt decider >>>> does not care and does not know the difference I named the single >>>> dynamic behavior pattern the [infinite recursion] dynamic behavior >>>> pattern. >>> >>> The issue is you ignore some 'detail' that actually IS important. >>> >>> Like the fact that the subroutine 'Halts' when called by H_Hat is PART >>> OF H_HAT, and that its decision to stop simulating the input it was >>> given does NOT make H_Hat an 'infinite recursion' >> >> >> An infinite loop is correctly decided to specify non halting behavior on >> the basis that it matches the [infinite loop] dynamic behavior pattern. >> The fact that it does halt because the halt decider forced it to halt >> does not change this. >> >> The fact that H_Hat() always matches the [infinite recursion]** dynamic >> behavior pattern (when it is executed with itself as input) is what >> makes the halt decider's decision correct. The fact that it does halt >> because the halt decider forced it to halt does not change this. >> >> ** Also applies to infinitely nested simulations. >> > > If you say H_Hat matches your infinite recursion pattern, your pattern > is WRONG. This is a rule you are making up yourself, so has no proof of > being correct. If the execution trace of function Y() shows: function X() is called twice in sequence from the same machine address of Y() with the same parameters to X() with no conditional branch or indexed jump instructions in Y() with no function call returns from X() then the function call from Y() to X() is infinitely recursive. You won't be able to show any error because the above is correct. This same dynamic behavior pattern also correctly recognizes infinitely nested simulations. -- 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-04 11:40 -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 | <OVdkI.220391$J_5.157907@fx46.iad> |
| In reply to | #32676 |
On 5/4/21 11:28 AM, olcott wrote: > On 5/4/2021 10:21 AM, Richard Damon wrote: >> On 5/4/21 10:53 AM, olcott wrote: >>> On 5/3/2021 2:23 PM, Richard Damon wrote: >>>> On 5/3/21 3:00 PM, olcott wrote: >>>>> On 5/3/2021 11:23 AM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> 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. >>>>>> >>>>>> All the smoke you are trying to blow below can not detract from this >>>>>> end >>>>>> result. You are stupidly trying to get away with the wrong answer. >>>>>> >>>>>>>>>>>>> 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. >>>>>> >>>>>> I /think/ this means that you now know you used the wrong words >>>>>> but you >>>>>> were not trying to mislead anyone. Is that about it? >>>>> >>>>> I always speak in terms of the essential gist of things not paying >>>>> attention to the microscopic details. >>>>> >>>>> Because it is ridiculously obvious that infinitely nested >>>>> simulation has >>>>> computationally identical halting behavior to infinite recursion and >>>>> both non halting behavior patterns are identical and the halt decider >>>>> does not care and does not know the difference I named the single >>>>> dynamic behavior pattern the [infinite recursion] dynamic behavior >>>>> pattern. >>>> >>>> The issue is you ignore some 'detail' that actually IS important. >>>> >>>> Like the fact that the subroutine 'Halts' when called by H_Hat is PART >>>> OF H_HAT, and that its decision to stop simulating the input it was >>>> given does NOT make H_Hat an 'infinite recursion' >>> >>> >>> An infinite loop is correctly decided to specify non halting behavior on >>> the basis that it matches the [infinite loop] dynamic behavior pattern. >>> The fact that it does halt because the halt decider forced it to halt >>> does not change this. >>> >>> The fact that H_Hat() always matches the [infinite recursion]** dynamic >>> behavior pattern (when it is executed with itself as input) is what >>> makes the halt decider's decision correct. The fact that it does halt >>> because the halt decider forced it to halt does not change this. >>> >>> ** Also applies to infinitely nested simulations. >>> >> >> If you say H_Hat matches your infinite recursion pattern, your pattern >> is WRONG. This is a rule you are making up yourself, so has no proof of >> being correct. > > If the execution trace of function Y() shows: > function X() is called twice in sequence from the same machine address > of Y() > with the same parameters to X() > with no conditional branch or indexed jump instructions in Y() > with no function call returns from X() > then the function call from Y() to X() is infinitely recursive. > > You won't be able to show any error because the above is correct. > > This same dynamic behavior pattern also correctly recognizes infinitely > nested simulations. > BAD RULE. As I have said, that fact that X is called from Y means that the decision in X are part of the Computation of Y. If X really is a Compuation, the it will always do the same thing, and thus calling X itself won't return so it can't be a decider. In this case, X ISN'T Really a function, but is a simualtion hook, so the whole arguement by comparison is flawed Since you ignored this proof: 1) Halts is stipulated to meet the requirements of a Halt Decider for Computation Theory, as used in the proof of Linz and Sipser. 2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat) when asked directly. 3) H_Hat is stipulated to be built like Linz or Sipser, in that it will halt when the Halt decider it is built on decides H_Hat’s input is non-Halting on itself. 4) 1 Means that Halts is a Computation, and will always return the same answer (or never return an answer) for a given input. 5) H_Hat(H_Hat) when run as a Machine will perform the Computation Halts(H_Hat, H_Hat) 6) by 4 and 2, this means that Halts will return the decision on non-halting to H_Hat 7) By 3, this means that H_Hat will Halt. I presume that means that you don't see an error in it and are just continuing to ramble incoherently trying to prove something that is false. I won't comment further on the Y/X rule in some other setting, because frankly it doesn't apply here and is just a starwman. Halts is WRONG about H_Hat. Face it. You logic system is bogus, a failure, garbage.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-04 17:11 +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 | <87sg324gxd.fsf@bsb.me.uk> |
| In reply to | #32667 |
olcott <NoOne@NoWhere.com> writes: > An infinite loop is correctly decided to specify non halting behavior > on the basis that it matches the [infinite loop] dynamic behavior > pattern. Fannel, of no significance to anyone but you. > The fact that it does halt because the halt decider forced > it to halt does not change this. The fact that it halts, for whatever reason, makes it a halting computation. It should be reported as such. Your function returns the wrong answer. > The fact that H_Hat() always matches the [infinite recursion]** > dynamic behavior pattern (when it is executed with itself as input) is > what makes the halt decider's decision correct. The fact that it halts makes the decider's decision incorrect. You know this. When I asked you to confirm the simple fact that "no" is the correct return value for non-halting computations and "yes" for the others, you squirmed and dodged and equivocated. You would only agree the every instance of the halting problem represents a computation either halts or does not halt. You would not take the last tiny step because you knew you wanted to continue to deny that "yes" (true) is the correct answer for every single halting computation. I can't imagine how you think anyone will take this seriously. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 11:23 -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 | <ceydnShvvKZy6Qz9nZ2dnUU7-bHNnZ2d@giganews.com> |
| In reply to | #32684 |
On 5/4/2021 11:11 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> An infinite loop is correctly decided to specify non halting behavior
>> on the basis that it matches the [infinite loop] dynamic behavior
>> pattern.
>
> Fannel, of no significance to anyone but you.
>
>> The fact that it does halt because the halt decider forced
>> it to halt does not change this.
>
> The fact that it halts, for whatever reason, makes it a halting
> computation. It should be reported as such. Your function returns the
> wrong answer.
Because you are saying that infinite loops specify halting behavior as
always I stop of the first big mistake.
As soon as any computation matches the dynamic behavior pattern of
non-halting behavior a halt decider does correctly decide not halting on
this input string.
_Infinite_Loop()
[00000aaf](01) 55 push ebp
[00000ab0](02) 8bec mov ebp,esp
[00000ab2](02) ebfe jmp 00000ab2
[00000ab4](01) 5d pop ebp
[00000ab5](01) c3 ret
Size in bytes:(0007) [00000ab5]
void Infinite_Loop()
{
HERE: goto HERE;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)Infinite_Loop, (u32)Infinite_Loop);
Output("Input_Would_Halt = ", Input_Would_Halt);
}
>
>> The fact that H_Hat() always matches the [infinite recursion]**
>> dynamic behavior pattern (when it is executed with itself as input) is
>> what makes the halt decider's decision correct.
>
> The fact that it halts makes the decider's decision incorrect.
>
> You know this. When I asked you to confirm the simple fact that "no" is
> the correct return value for non-halting computations and "yes" for the
> others, you squirmed and dodged and equivocated. You would only agree
> the every instance of the halting problem represents a computation
> either halts or does not halt. You would not take the last tiny step
> because you knew you wanted to continue to deny that "yes" (true) is the
> correct answer for every single halting computation.
>
> I can't imagine how you think anyone will take this seriously.
>
--
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-04 12:40 -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 | <KNekI.260132$2A5.170323@fx45.iad> |
| In reply to | #32685 |
On 5/4/21 12:23 PM, olcott wrote: > On 5/4/2021 11:11 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> An infinite loop is correctly decided to specify non halting behavior >>> on the basis that it matches the [infinite loop] dynamic behavior >>> pattern. >> >> Fannel, of no significance to anyone but you. >> >>> The fact that it does halt because the halt decider forced >>> it to halt does not change this. >> >> The fact that it halts, for whatever reason, makes it a halting >> computation. It should be reported as such. Your function returns the >> wrong answer. > > Because you are saying that infinite loops specify halting behavior as > always I stop of the first big mistake. Except that he never said that Infinite Loops specifies Halting Behavior. The fact that the Simulator stopped Simulating it does NOT mean that the computation halted. YOU are the one who conflates these two thing. First Error, Halted.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 11:46 -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 | <7vKdnce7iPLJ5wz9nZ2dnUU7-X_NnZ2d@giganews.com> |
| In reply to | #32686 |
On 5/4/2021 11:40 AM, Richard Damon wrote: > On 5/4/21 12:23 PM, olcott wrote: >> On 5/4/2021 11:11 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> An infinite loop is correctly decided to specify non halting behavior >>>> on the basis that it matches the [infinite loop] dynamic behavior >>>> pattern. >>> >>> Fannel, of no significance to anyone but you. >>> >>>> The fact that it does halt because the halt decider forced >>>> it to halt does not change this. >>> >>> The fact that it halts, for whatever reason, makes it a halting >>> computation. It should be reported as such. Your function returns the >>> wrong answer. >> >> Because you are saying that infinite loops specify halting behavior as >> always I stop of the first big mistake. > > Except that he never said that Infinite Loops specifies Halting Behavior. > > The fact that the Simulator stopped Simulating it does NOT mean that the > computation halted. > He disagrees: On 5/4/2021 11:11 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> An infinite loop is correctly decided to specify non halting behavior >> on the basis that it matches the [infinite loop] dynamic behavior >> pattern. > >> The fact that it does halt because the halt decider forced >> it to halt does not change this. > > The fact that it halts, for whatever reason, makes it a halting > computation. It should be reported as such. Your function > returns the wrong answer. -- 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-04 13:17 -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 | <ZkfkI.50658$RC2.38216@fx27.iad> |
| In reply to | #32689 |
On 5/4/21 12:46 PM, olcott wrote: > On 5/4/2021 11:40 AM, Richard Damon wrote: >> On 5/4/21 12:23 PM, olcott wrote: >>> On 5/4/2021 11:11 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> An infinite loop is correctly decided to specify non halting behavior >>>>> on the basis that it matches the [infinite loop] dynamic behavior >>>>> pattern. >>>> >>>> Fannel, of no significance to anyone but you. >>>> >>>>> The fact that it does halt because the halt decider forced >>>>> it to halt does not change this. >>>> >>>> The fact that it halts, for whatever reason, makes it a halting >>>> computation. It should be reported as such. Your function returns the >>>> wrong answer. >>> >>> Because you are saying that infinite loops specify halting behavior as >>> always I stop of the first big mistake. >> >> Except that he never said that Infinite Loops specifies Halting Behavior. >> >> The fact that the Simulator stopped Simulating it does NOT mean that the >> computation halted. >> > > He disagrees: > > On 5/4/2021 11:11 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> An infinite loop is correctly decided to specify non halting behavior >>> on the basis that it matches the [infinite loop] dynamic behavior >>> pattern. >> >>> The fact that it does halt because the halt decider forced >>> it to halt does not change this. >> >> The fact that it halts, for whatever reason, makes it a halting >> computation. It should be reported as such. Your function >> returns the wrong answer. > BAD SNIPAGE. His comment was pointing to the 'Infinite Loop' you were calling in the computation of H_Hat beng 'simulated' by Halts That Loop, even though you want to call it 'infinite' does stop on its own, so is finite. If your best arguments are based on misinterpreting and misrepresenting what other say, you have lost already. H_Hat(H_Hat) is a halting computation. PERIOD. You have shown yourself to be a liar, and to try to make your point by misquoting people. For someone who seems to want to stand on the principal that ALL Truth should be provable, you are so very weak on providing real analytic proof of your own words. I would suggest that you practice what you preach. LEARN what it actually means to make a REAL analytical arguement. Don't worry that 'rote book learning' might teach you that you can't do some things. Most of those things are really things you can't do by the rules of logic. Things like you don't disprove a real proof by giving something that looks like a counter example. Yes, a counter example may cause a review of the proof to make sure it was sound, but it also causes a similar review of the counter example to make sure it is correct. This is because if you DO have a proof that says X, and an counter example that says NOT X, then if you can't find an error in either, you need to assume the logical system has become inconsistent. For well established systems, that means your counter example needs to stand up to exceptional scrutiny. The fact that you get so much argument over your proof should be seen as signs that you are anywhere near being ready to stand up to that. Your whole argument is based on your own self-evident proclamations. Those will NOT be just accepted, and will be seen as the SOURCE of the inconsistency. You won't be able to just rhetorically argue that they must be true, you will need to establish firm analytical basis for them, and to do that, you will need a much better knowledge of the field.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-04 21:47 +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 | <87zgxa2pl8.fsf@bsb.me.uk> |
| In reply to | #32685 |
olcott <NoOne@NoWhere.com> writes: > On 5/4/2021 11:11 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> An infinite loop is correctly decided to specify non halting behavior >>> on the basis that it matches the [infinite loop] dynamic behavior >>> pattern. >> >> Fannel, of no significance to anyone but you. >> >>> The fact that it does halt because the halt decider forced >>> it to halt does not change this. >> >> The fact that it halts, for whatever reason, makes it a halting >> computation. It should be reported as such. Your function returns the >> wrong answer. > > Because you are saying that infinite loops specify halting behavior as > always I stop of the first big mistake. Good grief you say the silliest things! H_Hat(H_Hat) is a finite computation*. If that fact is at odds with the name you give whatever pattern Halts is designed to find, that is your mistake, not mine. You really should stop trying to re-words what other people say. I gave you the benefit of the doubt and called your remark silly, but you do this so often some people might think it's deliberate. * This fact has been stated by you, verified (so I am led to believe) by a trace posted by you, and can be checked from the logic of what little code you habe not kept hidden. >> I can't imagine how you think anyone will take this seriously. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-04 17:31 -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 | <j3jkI.336005$2N3.306761@fx33.iad> |
| In reply to | #32706 |
On 5/4/21 4:47 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 5/4/2021 11:11 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> An infinite loop is correctly decided to specify non halting behavior
>>>> on the basis that it matches the [infinite loop] dynamic behavior
>>>> pattern.
>>>
>>> Fannel, of no significance to anyone but you.
>>>
>>>> The fact that it does halt because the halt decider forced
>>>> it to halt does not change this.
>>>
>>> The fact that it halts, for whatever reason, makes it a halting
>>> computation. It should be reported as such. Your function returns the
>>> wrong answer.
>>
>> Because you are saying that infinite loops specify halting behavior as
>> always I stop of the first big mistake.
>
> Good grief you say the silliest things! H_Hat(H_Hat) is a finite
> computation*. If that fact is at odds with the name you give whatever
> pattern Halts is designed to find, that is your mistake, not mine.
>
> You really should stop trying to re-words what other people say. I gave
> you the benefit of the doubt and called your remark silly, but you do
> this so often some people might think it's deliberate.
>
> * This fact has been stated by you, verified (so I am led to believe) by
> a trace posted by you, and can be checked from the logic of what
> little code you habe not kept hidden.
>
Yes, he posted the following trace where he forgot to remove the end
which shows that H_Hat does Halt when run by itself (I keep the date
stamp so the post can be found):
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
Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:
> ...[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
SEE IT HALTED!
> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)
>
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-04 23:21 +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 | <87czu62l8r.fsf@bsb.me.uk> |
| In reply to | #32708 |
Richard Damon <Richard@Damon-Family.org> writes: > On 5/4/21 4:47 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 5/4/2021 11:11 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> An infinite loop is correctly decided to specify non halting behavior >>>>> on the basis that it matches the [infinite loop] dynamic behavior >>>>> pattern. >>>> >>>> Fannel, of no significance to anyone but you. >>>> >>>>> The fact that it does halt because the halt decider forced >>>>> it to halt does not change this. >>>> >>>> The fact that it halts, for whatever reason, makes it a halting >>>> computation. It should be reported as such. Your function returns the >>>> wrong answer. >>> >>> Because you are saying that infinite loops specify halting behavior as >>> always I stop of the first big mistake. >> >> Good grief you say the silliest things! H_Hat(H_Hat) is a finite >> computation*. If that fact is at odds with the name you give whatever >> pattern Halts is designed to find, that is your mistake, not mine. >> >> You really should stop trying to re-words what other people say. I gave >> you the benefit of the doubt and called your remark silly, but you do >> this so often some people might think it's deliberate. >> >> * This fact has been stated by you, verified (so I am led to believe) by >> a trace posted by you, and can be checked from the logic of what >> little code you habe not kept hidden. > > Yes, he posted the following trace where he forgot to remove the end > which shows that H_Hat does Halt when run by itself (I keep the date > stamp so the post can be found): Thanks. I thought I'd seen this, but I did not want to say so without being 100% sure. I usually just rely on the post where he told me, and it can be worked out form the code snippets, so there is no doubt. He has never challenged the fact, at least when I've stated it. It came out during his "I've redefined what a halting computation is" period. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-04 00:49 +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 | <874kfj5qfm.fsf@bsb.me.uk> |
| In reply to | #32653 |
olcott <NoOne@NoWhere.com> writes:
> On 5/3/2021 11:23 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/2/2021 6:52 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>> 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.
>>
>> In the case that matters, Halts(H_Hat, H_Hat), (when Halts gets the
>> answer wrong) Halts again detects something "computationally equivalent
>> to infinite recursion" but the arguments to Halts denote a finite
>> computation do they not?
>
> <sarcasm>
> Yes of course every knows that all infinite loops automatically stop
> at the very first iteration that is why they are called infinite
> loops. "Infinite" in this context means {a single
> iteration}. </sarcasm>
Too embarrassed to take the question seriously?
>> What new level of crazy language is this?
>>> Infinite recursion and infinite nested simulations demonstrate the
>>> exact same dynamic behavior pattern.
>>
>> Don't be silly.
>
> They demonstrate this exact same behavior pattern
>> They demonstrate quite different behaviours. You misuse "exact" like
>> this all the time.
Any future readers can decide if "infinite recursion and infinite nested
simulations" really do "demonstrate the /exact/ same dynamic behavior
pattern" (emphasis mine).
>>>> 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.
>>
>> So you won't say if the trace shows actual calls? You would be sure to
>> point it out if it didn't, so I think it is safe to assume it does!
>
> I have shown the actual calls many hundreds of times over the last six
> months.
I know. Is "yes" or "no" too hard for you to type? Or do you want to
avoid actually making a statement that might be wrong. Anyway, dodging
direct questions is now your number one strategy.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 10:09 -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-dneStWMoy_gz9nZ2dnUU7-RPNnZ2d@giganews.com> |
| In reply to | #32659 |
On 5/3/2021 6:49 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 5/3/2021 11:23 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/2/2021 6:52 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>
>>>>>> 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.
>>>
>>> In the case that matters, Halts(H_Hat, H_Hat), (when Halts gets the
>>> answer wrong) Halts again detects something "computationally equivalent
>>> to infinite recursion" but the arguments to Halts denote a finite
>>> computation do they not?
>>
>> <sarcasm>
>> Yes of course every knows that all infinite loops automatically stop
>> at the very first iteration that is why they are called infinite
>> loops. "Infinite" in this context means {a single
>> iteration}. </sarcasm>
>
> Too embarrassed to take the question seriously?
>
>>> What new level of crazy language is this?
>
>>>> Infinite recursion and infinite nested simulations demonstrate the
>>>> exact same dynamic behavior pattern.
>>>
>>> Don't be silly.
>>
>> They demonstrate this exact same behavior pattern
>
>>> They demonstrate quite different behaviours. You misuse "exact" like
>>> this all the time.
>
> Any future readers can decide if "infinite recursion and infinite nested
> simulations" really do "demonstrate the /exact/ same dynamic behavior
> pattern" (emphasis mine).
>
>>>>> 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.
>>>
>>> So you won't say if the trace shows actual calls? You would be sure to
>>> point it out if it didn't, so I think it is safe to assume it does!
>>
>> I have shown the actual calls many hundreds of times over the last six
>> months.
>
> I know. Is "yes" or "no" too hard for you to type? Or do you want to
> avoid actually making a statement that might be wrong. Anyway, dodging
> direct questions is now your number one strategy.
>
If you are going to be so damn disrespectful as to make sure that you
always ignore most of what I say when you are artificially contrive a
rebuttal on one unsound basis or another providing a respectful reply
encourages this disrespectful behavior.
You can look up the answer here:
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 | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 10: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 | <Gv6dndg9Z8dv9gz9nZ2dnUU7-QfNnZ2d@giganews.com> |
| In reply to | #32659 |
On 5/3/2021 6:49 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 5/3/2021 11:23 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/2/2021 6:52 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>
>>>>>> 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.
>>>
>>> In the case that matters, Halts(H_Hat, H_Hat), (when Halts gets the
>>> answer wrong) Halts again detects something "computationally equivalent
>>> to infinite recursion" but the arguments to Halts denote a finite
>>> computation do they not?
>>
>> <sarcasm>
>> Yes of course every knows that all infinite loops automatically stop
>> at the very first iteration that is why they are called infinite
>> loops. "Infinite" in this context means {a single
>> iteration}. </sarcasm>
>
> Too embarrassed to take the question seriously?
>
Answered in the original reply
>>> What new level of crazy language is this?
>
>>>> Infinite recursion and infinite nested simulations demonstrate the
>>>> exact same dynamic behavior pattern.
>>>
>>> Don't be silly.
>>
>> They demonstrate this exact same behavior pattern
>
>>> They demonstrate quite different behaviours. You misuse "exact" like
>>> this all the time.
>
> Any future readers can decide if "infinite recursion and infinite nested
> simulations" really do "demonstrate the /exact/ same dynamic behavior
> pattern" (emphasis mine).
>
Exact same behavior and exact same behavior patterns are two distinctly
different levels of abstraction that you seemed to have failed to notice.
--
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 19:50 +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 | <87bl9q49lg.fsf@bsb.me.uk> |
| In reply to | #32680 |
olcott <NoOne@NoWhere.com> writes:
> On 5/3/2021 6:49 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/3/2021 11:23 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/2/2021 6:52 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>>>> 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.
>>>>
>>>> In the case that matters, Halts(H_Hat, H_Hat), (when Halts gets the
>>>> answer wrong) Halts again detects something "computationally equivalent
>>>> to infinite recursion" but the arguments to Halts denote a finite
>>>> computation do they not?
>>>
>>> <sarcasm>
>>> Yes of course every knows that all infinite loops automatically stop
>>> at the very first iteration that is why they are called infinite
>>> loops. "Infinite" in this context means {a single
>>> iteration}. </sarcasm>
>>
>> Too embarrassed to take the question seriously?
>
> Answered in the original reply
No.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 10:04 -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 | <N8ednVfUbsjR_wz9nZ2dnUU7-bnNnZ2d@giganews.com> |
| In reply to | #32644 |
On 5/3/2021 11:23 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> 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.
>
> All the smoke you are trying to blow below can not detract from this end
> result. You are stupidly trying to get away with the wrong answer.
>
>>>>>>>> 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.
>
> I /think/ this means that you now know you used the wrong words but you
> were not trying to mislead anyone. Is that about it?
>
>>>>> 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.
>
> In the case that matters, Halts(H_Hat, H_Hat), (when Halts gets the
> answer wrong) Halts again detects something "computationally equivalent
> to infinite recursion" but the arguments to Halts denote a finite
> computation do they not?
Halts(H_Hat, H_Hat) correctly decides not halting on the basis that
H_Hat(H_Hat) matches the [infinite recursion]** dynamic behavior pattern.
An infinite loop is correctly decided to specify non halting behavior on
the basis that it matches the [infinite loop] dynamic behavior pattern.
The fact that it does halt because the halt decider forced it to halt
does not change this.
The fact that H_Hat() always matches the [infinite recursion]** dynamic
behavior pattern (when it is executed with itself as input) is what
makes the halt decider's decision correct. The fact that it does halt
because the halt decider forced it to halt does not change this.
** Also applies to infinitely nested simulations.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 3 of 5 — ← Prev page 1 2 [3] 4 5 Next page →
Back to top | Article view | comp.theory
csiph-web