Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.theory > #32496 > unrolled thread

Mutual agreement on the definition of a [computation] in computer science

Started byolcott <NoOne@NoWhere.com>
First post2021-05-01 11:30 -0500
Last post2021-05-02 21:46 +0100
Articles 20 on this page of 92 — 7 participants

Back to article view | Back to comp.theory


Contents

  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 →


#32644 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-03 17:23 +0100
SubjectRe: 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]


#32653 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-03 14:00 -0500
SubjectRe: 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]


#32655 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-03 15:23 -0400
SubjectRe: 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]


#32667 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 09:53 -0500
SubjectRe: 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]


#32672 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-04 11:21 -0400
SubjectRe: 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]


#32676 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 10:28 -0500
SubjectRe: 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]


#32679 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-04 11:40 -0400
SubjectRe: 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]


#32684 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-04 17:11 +0100
SubjectRe: 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]


#32685 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 11:23 -0500
SubjectRe: 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]


#32686 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-04 12:40 -0400
SubjectRe: 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]


#32689 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 11:46 -0500
SubjectRe: 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]


#32694 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-04 13:17 -0400
SubjectRe: 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]


#32706 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-04 21:47 +0100
SubjectRe: 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]


#32708 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-04 17:31 -0400
SubjectRe: 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]


#32710 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-04 23:21 +0100
SubjectRe: 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]


#32659 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-04 00:49 +0100
SubjectRe: 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]


#32670 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 10:09 -0500
SubjectRe: 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]


#32680 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 10:45 -0500
SubjectRe: 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]


#32700 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-04 19:50 +0100
SubjectRe: 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]


#32669 — Re: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 10:04 -0500
SubjectRe: 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