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 2 of 5 — ← Prev page 1 [2] 3 4 5  Next page →


#32551 — 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-02 03:30 +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<871rapamv1.fsf@bsb.me.uk>
In reply to#32546
olcott <NoOne@NoWhere.com> writes:

> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>> infinite recursion is aborted at some point.
>>>>
>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>> why.  It is a finite computation, and should be reported as such.
>>>
>>> So in other words you believe that it is ridiculous for anyone to ever
>>> consider defining a partial halt decider because everyone agrees that
>>> is cannot be done perfectly so why bother doing this at all.
>>
>> No.  I am saying that your wording is silly because it attempts to
>> justify the wrong answer using another, different, computation.
>> H_Hat(H_Hat) is finite.

I see you don't dispute these facts.

> If the execution trace of function X() called by function Y() shows:
> (1) Function X() is called twice in sequence from the same machine address of Y().
> (2) With the same parameters to X().
> (3) With no conditional branch or indexed jump instructions in Y().
> (4) With no function call returns from X().
> then the function call from Y() to X() is infinitely recursive.
>
> The above criteria does correctly decide infinite recursion.

What has this got to do with the computation H_Hat(H_Hat) (the real one,
not the one you posted recently to poison the well)?  It calls no
functions that call H_Hat.  In the world of C and x86 code, that means
it is not recursive at all.

If you are tracing a call to Halts, then that is not relevant.  If
Halts is recursive, that says nothing about the computation that
matters.

Other than explain why it can't matter, I won't discuss your traces
without seeing the code being traced, and the code the generates the
traces.  You lost the right to be considered an honest reporter of your
own work when you claimed to have two "actual Turing machines", "fully
encoded", "exactly and precisely as in Linz".

> The above criteria does correctly decide infinite recursion.
> The above criteria does correctly decide infinite recursion.
>
> Every call from H_Hat() to Halts() meets this criteria.
> Every call from H_Hat() to Halts() meets this criteria.
> Every call from H_Hat() to Halts() meets this criteria.
>
> Ignoring this key fact is no form of correct rebuttal.

You ignored the key facts I put to you.  These were facts that you told
me so you are stuck with them until you correct the record.  You told me
that:

(a) Halts(H_Hat, H_Hat) is false, and
(b) H_Hat(H_Hat) is a finite computation.

(You actually said "the input to Halts is finite" but you meant what (b)
says).

No trace can make the wrong answer correct.  This has not changed since
last year, and until you correct the record, you are reduced to trying
to find linguistic circumlocutions to explain why the wrong answer is
the right answer.

> Ignoring this key fact is no form of correct rebuttal.
> Ignoring this key fact is no form of correct rebuttal.

This repetition is even sillier than your original silly words.  Please
don't stop doing it.  It's important that people see it in the record.
I recommend ALL CAPS and at least a dozen repetitions.

>> Halts(H_Hat, H_Hat) should be true, but you
>> have written Halts so that it's false and you justify that wrong answer
>> by what would happen were things not as they are.  It's flagrant
>> silliness.
>
>> When you find yourself starting off "So in other words you believe..."
>> you should stop and ask yourself, "what point am I trying to avoid by
>> putting words into my interlocutor's mounth?".

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#32553 — 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-01 23:36 -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<CcSdnSKKCqSgsRP9nZ2dnUU7-cXNnZ2d@giganews.com>
In reply to#32551
On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>> infinite recursion is aborted at some point.
>>>>>
>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>> why.  It is a finite computation, and should be reported as such.
>>>>
>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>> consider defining a partial halt decider because everyone agrees that
>>>> is cannot be done perfectly so why bother doing this at all.
>>>
>>> No.  I am saying that your wording is silly because it attempts to
>>> justify the wrong answer using another, different, computation.
>>> H_Hat(H_Hat) is finite.
> 
> I see you don't dispute these facts.
> 
>> If the execution trace of function X() called by function Y() shows:
>> (1) Function X() is called twice in sequence from the same machine address of Y().
>> (2) With the same parameters to X().
>> (3) With no conditional branch or indexed jump instructions in Y().
>> (4) With no function call returns from X().
>> then the function call from Y() to X() is infinitely recursive.
>>
>> The above criteria does correctly decide infinite recursion.
> 
> What has this got to do with the computation H_Hat(H_Hat) (the real one,
> not the one you posted recently to poison the well)?  It calls no
> functions that call H_Hat.  In the world of C and x86 code, that means
> it is not recursive at all.
> 
> If you are tracing a call to Halts, then that is not relevant.  If
> Halts is recursive, that says nothing about the computation that
> matters.
> 
> Other than explain why it can't matter, I won't discuss your traces
> without seeing the code being traced, and the code the generates the
> traces.  You lost the right to be considered an honest reporter of your
> own work when you claimed to have two "actual Turing machines", "fully
> encoded", "exactly and precisely as in Linz".
> 
>> The above criteria does correctly decide infinite recursion.
>> The above criteria does correctly decide infinite recursion.
>>
>> Every call from H_Hat() to Halts() meets this criteria.
>> Every call from H_Hat() to Halts() meets this criteria.
>> Every call from H_Hat() to Halts() meets this criteria.
>>
>> Ignoring this key fact is no form of correct rebuttal.
> 

> You ignored the key facts I put to you.  These were facts that you told
> me so you are stuck with them until you correct the record.  

The key fact is that every time H_Hat() calls Halts() it meets the above 
criteria of infinite recursion, you can dodge this fact but you cannot 
correctly refute this fact.

The key "facts" that you presented dodged rather than addressed this 
point. You are bright enough to confirm that the above <is> correct 
infinite recursion criteria. You also know that when complete infinite 
recursion criteria is met then we <have> infinite recursion.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#32559 — 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-02 07:51 -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<PmwjI.178495$ST2.62135@fx47.iad>
In reply to#32553
On 5/2/21 12:36 AM, olcott wrote:
> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>> infinite recursion is aborted at some point.
>>>>>>
>>>>>> This is just a silly word game.  What a computation would do
>>>>>> "otherwise"
>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>
>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>> consider defining a partial halt decider because everyone agrees that
>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>
>>>> No.  I am saying that your wording is silly because it attempts to
>>>> justify the wrong answer using another, different, computation.
>>>> H_Hat(H_Hat) is finite.
>>
>> I see you don't dispute these facts.
>>
>>> If the execution trace of function X() called by function Y() shows:
>>> (1) Function X() is called twice in sequence from the same machine
>>> address of Y().
>>> (2) With the same parameters to X().
>>> (3) With no conditional branch or indexed jump instructions in Y().
>>> (4) With no function call returns from X().
>>> then the function call from Y() to X() is infinitely recursive.
>>>
>>> The above criteria does correctly decide infinite recursion.
>>
>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>> not the one you posted recently to poison the well)?  It calls no
>> functions that call H_Hat.  In the world of C and x86 code, that means
>> it is not recursive at all.
>>
>> If you are tracing a call to Halts, then that is not relevant.  If
>> Halts is recursive, that says nothing about the computation that
>> matters.
>>
>> Other than explain why it can't matter, I won't discuss your traces
>> without seeing the code being traced, and the code the generates the
>> traces.  You lost the right to be considered an honest reporter of your
>> own work when you claimed to have two "actual Turing machines", "fully
>> encoded", "exactly and precisely as in Linz".
>>
>>> The above criteria does correctly decide infinite recursion.
>>> The above criteria does correctly decide infinite recursion.
>>>
>>> Every call from H_Hat() to Halts() meets this criteria.
>>> Every call from H_Hat() to Halts() meets this criteria.
>>> Every call from H_Hat() to Halts() meets this criteria.
>>>
>>> Ignoring this key fact is no form of correct rebuttal.
>>
> 
>> You ignored the key facts I put to you.  These were facts that you told
>> me so you are stuck with them until you correct the record.  
> 
> The key fact is that every time H_Hat() calls Halts() it meets the above
> criteria of infinite recursion, you can dodge this fact but you cannot
> correctly refute this fact.
> 
> The key "facts" that you presented dodged rather than addressed this
> point. You are bright enough to confirm that the above <is> correct
> infinite recursion criteria. You also know that when complete infinite
> recursion criteria is met then we <have> infinite recursion.
> 
> 
First, it is NOT recursion, because Halts doesn't 'Call' H_Hat, it know
nothing of H_Hat in its algorithm. It is NOT recursion.

Second, if you do redefine the simulation to be like a call to get
recursion, then for H_Hat to call Halts to be infinite recursion, so
would Halts 'calling' H_Hat, so Halts would be a non-Halting
computation, and thus not a decider.

THis is NOT what happens.

If fact, YOU even published a trace of this execution showing that
H_Hat, when not being run under a halt decider, so NOT able to be
'aborted', actually comes to a Halt by itself, thus showing it to be a
Halting Computation: (Yes, the Halts within H_Hat reports that it
aborted its simulation of its copy of H_Hat, but that isn't aborting the
H_Hat that we are looking at).

On 4/27/21 12:55 AM, olcott wrote:
> void H_Hat(u32 P)
> {
>  u32 Input_Halts = Halts(P, P);
>  if (Input_Halts)
>    HERE: goto HERE;
> }
>
>
> int main()
> {
>  H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01)  55                  	push ebp
> [00000b99](02)  8bec                	mov ebp,esp
> [00000b9b](01)  51                  	push ecx
> [00000b9c](03)  8b4508              	mov eax,[ebp+08]
> [00000b9f](01)  50                  	push eax
> [00000ba0](03)  8b4d08              	mov ecx,[ebp+08]
> [00000ba3](01)  51                  	push ecx
> [00000ba4](05)  e88ffdffff          	call 00000938
> [00000ba9](03)  83c408              	add esp,+08
> [00000bac](03)  8945fc              	mov [ebp-04],eax
> [00000baf](04)  837dfc00            	cmp dword [ebp-04],+00
> [00000bb3](02)  7402                	jz 00000bb7
> [00000bb5](02)  ebfe                	jmp 00000bb5
> [00000bb7](02)  8be5                	mov esp,ebp
> [00000bb9](01)  5d                  	pop ebp
> [00000bba](01)  c3                  	ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01)  55                  	push ebp
> [00000bc9](02)  8bec                	mov ebp,esp
> [00000bcb](05)  68980b0000          	push 00000b98
> [00000bd0](05)  e8c3ffffff          	call 00000b98
> [00000bd5](03)  83c404              	add esp,+04
> [00000bd8](02)  33c0                	xor eax,eax
> [00000bda](01)  5d                  	pop ebp
> [00000bdb](01)  c3                  	ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01)  55                  	push ebp
> ...[00000bc9][001015d4][00000000](02)  8bec                	mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05)  68980b0000          	push
> 00000b98
> ...[00000bd0][001015cc][00000bd5](05)  e8c3ffffff          	call
> 00000b98
> ...[00000b98][001015c8][001015d4](01)  55                  	push ebp
> ...[00000b99][001015c8][001015d4](02)  8bec                	mov ebp,esp
> ...[00000b9b][001015c4][00000000](01)  51                  	push ecx
> ...[00000b9c][001015c4][00000000](03)  8b4508              	mov
> eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01)  50                  	push eax
> ...[00000ba0][001015c0][00000b98](03)  8b4d08              	mov
> ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01)  51                  	push ecx
> ...[00000ba4][001015b8][00000ba9](05)  e88ffdffff          	call
> 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01)  55                  	push ebp
> ...[00000b99][00211674][00211678](02)  8bec                	mov ebp,esp
> ...[00000b9b][00211670][00201644](01)  51                  	push ecx
> ...[00000b9c][00211670][00201644](03)  8b4508              	mov
> eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01)  50                  	push eax
> ...[00000ba0][0021166c][00000b98](03)  8b4d08              	mov
> ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01)  51                  	push ecx
> ...[00000ba4][00211664][00000ba9](05)  e88ffdffff          	call
> 00000938
> ...[00000b98][0025c09c][0025c0a0](01)  55                  	push ebp
> ...[00000b99][0025c09c][0025c0a0](02)  8bec                	mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01)  51                  	push ecx
> ...[00000b9c][0025c098][0024c06c](03)  8b4508              	mov
> eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01)  50                  	push eax
> ...[00000ba0][0025c094][00000b98](03)  8b4d08              	mov
> ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01)  51                  	push ecx
> ...[00000ba4][0025c08c][00000ba9](05)  e88ffdffff          	call
> 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> ...[00000ba9][001015c4][00000000](03)  83c408              	add esp,+08
> ...[00000bac][001015c4][00000000](03)  8945fc              	mov
> [ebp-04],eax
> ...[00000baf][001015c4][00000000](04)  837dfc00            	cmp dword
> [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02)  7402                	jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02)  8be5                	mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01)  5d                  	pop ebp
> ...[00000bba][001015d0][00000b98](01)  c3                  	ret
> ...[00000bd5][001015d4][00000000](03)  83c404              	add esp,+04
> ...[00000bd8][001015d4][00000000](02)  33c0                	xor eax,eax
> ...[00000bda][001015d8][00100000](01)  5d                  	pop ebp
> ...[00000bdb][001015dc][00000098](01)  c3                  	ret
> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)
>

You are using a WRONG definition of Halting, or at least a wrong
argument to try to say that it isn't halting.

[toc] | [prev] | [next] | [standalone]


#32592 — 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-02 21:38 +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<87wnsg7twk.fsf@bsb.me.uk>
In reply to#32553
olcott <NoOne@NoWhere.com> writes:

> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>> infinite recursion is aborted at some point.
>>>>>>
>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>
>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>> consider defining a partial halt decider because everyone agrees that
>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>
>>>> No.  I am saying that your wording is silly because it attempts to
>>>> justify the wrong answer using another, different, computation.
>>>> H_Hat(H_Hat) is finite.
>>
>> I see you don't dispute these facts.

Good to see these facts confirmed by you once again.  If you dispute
that you justify giving the wrong answer using another related
computation, all you need to do is say so (and correct the record where
you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
denote a finite computation).

>>> The above criteria does correctly decide infinite recursion.
>>
>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>> not the one you posted recently to poison the well)?  It calls no
>> functions that call H_Hat.  In the world of C and x86 code, that means
>> it is not recursive at all.

>> You ignored the key facts I put to you.  These were facts that you told
>> me so you are stuck with them until you correct the record.  
>
> The key fact is that every time H_Hat() calls Halts() it meets the
> above criteria of infinite recursion, you can dodge this fact but you
> cannot correctly refute this fact.

I am not dodging it -- I am telling you it's a lie.  I started out being
polite and technical, but it amounts to the same thing: if the trace
shows recursion, it is a fake.  The only clue you have given us at to
what Halts does made it plain that there is no recursive call, so the
trace you show is, as far anyone can tell, a fiction, a lie, published
in order to be able to show /something/ when you dare not show the code.
If the trace shows a recursive call, it does not comport with what you
have published about Halts and that makes one or other of those (the
sketch of Halts or the trace) a plain deception.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#32594 — 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-02 17:11 -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<OzEjI.193957$J_5.100214@fx46.iad>
In reply to#32592
On 5/2/21 4:38 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>
>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>
>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>
>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>> justify the wrong answer using another, different, computation.
>>>>> H_Hat(H_Hat) is finite.
>>>
>>> I see you don't dispute these facts.
> 
> Good to see these facts confirmed by you once again.  If you dispute
> that you justify giving the wrong answer using another related
> computation, all you need to do is say so (and correct the record where
> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
> denote a finite computation).
> 
>>>> The above criteria does correctly decide infinite recursion.
>>>
>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>> not the one you posted recently to poison the well)?  It calls no
>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>> it is not recursive at all.
> 
>>> You ignored the key facts I put to you.  These were facts that you told
>>> me so you are stuck with them until you correct the record.  
>>
>> The key fact is that every time H_Hat() calls Halts() it meets the
>> above criteria of infinite recursion, you can dodge this fact but you
>> cannot correctly refute this fact.
> 
> I am not dodging it -- I am telling you it's a lie.  I started out being
> polite and technical, but it amounts to the same thing: if the trace
> shows recursion, it is a fake.  The only clue you have given us at to
> what Halts does made it plain that there is no recursive call, so the
> trace you show is, as far anyone can tell, a fiction, a lie, published
> in order to be able to show /something/ when you dare not show the code.
> If the trace shows a recursive call, it does not comport with what you
> have published about Halts and that makes one or other of those (the
> sketch of Halts or the trace) a plain deception.
> 

Actually, I am not sure I would call it a 'lie' but just a very
different model of reality. From what I can infer from what we are told,
x86utm is designed as a simulator/halt decider designed to handle
systems with this sort of nested simulations.

Halts is not really a 'function' in the normal sense, but an entry point
into the simulator that converts the call to it to simulate/decide for a
provided input into a real 'simulated' call with some book keeping.

This sort of definition would generate the traces like he provides. It
also explains why you can't make a copy of Halts, as Halts isn't really
an self contained Computation, but just an entry point into the OS which
considers itself outside the system.

This of course says that Halts is NOT the equivalent of a Turing Machine
in a simple way, and thus H_Hat isn't really built the right way either.
To make a Turing Machine out of Halts, you likely need to wrap the whole
x86utm OS into the machine, and thus we go back to one of my proposals
where H_Hat needs to exec() x86utm to make the call.

Of course, as I recently pointed out, all these errors don't actually
let him properly decide on H_Hat. As long as the function call to Halts
acts like a computaton, always returning the same answer to all calls
with the same formal parameters, and we use the real definition of
Halting, that being what happens when we run the machine unimpaired, we
can show that Halts gets the answer wrong.

All he does with this subterfuge is to open the door for this crazy
notion that by confusing where Halts is actually operating, we can be
hornswaggled into believing that the operation of the Halts called
within the operation of H_Hat somehow doesn't count as being part of
H_Hat and thus it needing to perform the stopping means that H_Hat won't
stop on its own, and thus would seem to be non-Halting.

[toc] | [prev] | [next] | [standalone]


#32599 — 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 00:53 +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<87fsz47kvc.fsf@bsb.me.uk>
In reply to#32594
Richard Damon <Richard@Damon-Family.org> writes:

> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>
>>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>>
>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>
>>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>>> justify the wrong answer using another, different, computation.
>>>>>> H_Hat(H_Hat) is finite.
>>>>
>>>> I see you don't dispute these facts.
>> 
>> Good to see these facts confirmed by you once again.  If you dispute
>> that you justify giving the wrong answer using another related
>> computation, all you need to do is say so (and correct the record where
>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>> denote a finite computation).
>> 
>>>>> The above criteria does correctly decide infinite recursion.
>>>>
>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>> not the one you posted recently to poison the well)?  It calls no
>>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>>> it is not recursive at all.
>> 
>>>> You ignored the key facts I put to you.  These were facts that you told
>>>> me so you are stuck with them until you correct the record.  
>>>
>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>> above criteria of infinite recursion, you can dodge this fact but you
>>> cannot correctly refute this fact.
>> 
>> I am not dodging it -- I am telling you it's a lie.  I started out being
>> polite and technical, but it amounts to the same thing: if the trace
>> shows recursion, it is a fake.  The only clue you have given us at to
>> what Halts does made it plain that there is no recursive call, so the
>> trace you show is, as far anyone can tell, a fiction, a lie, published
>> in order to be able to show /something/ when you dare not show the code.
>> If the trace shows a recursive call, it does not comport with what you
>> have published about Halts and that makes one or other of those (the
>> sketch of Halts or the trace) a plain deception.
>
> Actually, I am not sure I would call it a 'lie' but just a very
> different model of reality. From what I can infer from what we are told,
> x86utm is designed as a simulator/halt decider designed to handle
> systems with this sort of nested simulations.
>
> Halts is not really a 'function' in the normal sense, but an entry point
> into the simulator that converts the call to it to simulate/decide for a
> provided input into a real 'simulated' call with some book keeping.

The best information we have about Halts (as far as I know) is a sketch
showing a loop that single-steps a simulation and a function call that
assesses whether to end the loop:

  bool Halts(u32 P, u32 I)
  {
    bool Halted  = false;
    bool Aborted = false;
    while (!Halted && !Aborted)
    {
      Halted  = DebugStep(P, I);
      Aborted = Needs_To_Be_Aborted();
    }
    return !Aborted;
  }

If the trace shows a recursive call, I'd call that a lie.  Something is
not as we've been led to believe.

Mind you, I refuse to look at the trace, so I am going by what PO says
about it.  Have I misunderstood him?  Does it not show Halts(H_Hat,
H_Hat) making recursive calls?

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#32602 — 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-02 19: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<k9ydne8WhMMN2hL9nZ2dnUU7-T3NnZ2d@giganews.com>
In reply to#32599
On 5/2/2021 6:53 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>
>>>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>>>
>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>
>>>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>> H_Hat(H_Hat) is finite.
>>>>>
>>>>> I see you don't dispute these facts.
>>>
>>> Good to see these facts confirmed by you once again.  If you dispute
>>> that you justify giving the wrong answer using another related
>>> computation, all you need to do is say so (and correct the record where
>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>> denote a finite computation).
>>>
>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>
>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>> not the one you posted recently to poison the well)?  It calls no
>>>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>>>> it is not recursive at all.
>>>
>>>>> You ignored the key facts I put to you.  These were facts that you told
>>>>> me so you are stuck with them until you correct the record.
>>>>
>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>> cannot correctly refute this fact.
>>>
>>> I am not dodging it -- I am telling you it's a lie.  I started out being
>>> polite and technical, but it amounts to the same thing: if the trace
>>> shows recursion, it is a fake.  The only clue you have given us at to
>>> what Halts does made it plain that there is no recursive call, so the
>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>> in order to be able to show /something/ when you dare not show the code.
>>> If the trace shows a recursive call, it does not comport with what you
>>> have published about Halts and that makes one or other of those (the
>>> sketch of Halts or the trace) a plain deception.
>>
>> Actually, I am not sure I would call it a 'lie' but just a very
>> different model of reality. From what I can infer from what we are told,
>> x86utm is designed as a simulator/halt decider designed to handle
>> systems with this sort of nested simulations.
>>
>> Halts is not really a 'function' in the normal sense, but an entry point
>> into the simulator that converts the call to it to simulate/decide for a
>> provided input into a real 'simulated' call with some book keeping.
> 
> The best information we have about Halts (as far as I know) is a sketch
> showing a loop that single-steps a simulation and a function call that
> assesses whether to end the loop:
> 
>    bool Halts(u32 P, u32 I)
>    {
>      bool Halted  = false;
>      bool Aborted = false;
>      while (!Halted && !Aborted)
>      {
>        Halted  = DebugStep(P, I);
>        Aborted = Needs_To_Be_Aborted();
>      }
>      return !Aborted;
>    }
> 
> If the trace shows a recursive call, I'd call that a lie.  Something is
> not as we've been led to believe.
> 
> Mind you, I refuse to look at the trace, so I am going by what PO says
> about it.  Have I misunderstood him?  Does it not show Halts(H_Hat,
> H_Hat) making recursive calls?
> 

In the above case it only shows that actual execution trace of whatever 
is input, unless the input must be aborted.

Infinitely nested simulations match the [Infinite Recursion] dynamic 
behavior pattern, and the halt decider does not need to know the 
difference.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#32605 — 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-02 20:56 -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<TSHjI.67049$b27.57508@fx03.iad>
In reply to#32602
On 5/2/21 8:45 PM, olcott wrote:
> On 5/2/2021 6:53 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its
>>>>>>>>>>> otherwise
>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>
>>>>>>>>>> This is just a silly word game.  What a computation would do
>>>>>>>>>> "otherwise"
>>>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter
>>>>>>>>>> how or
>>>>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>>>>
>>>>>>>>> So in other words you believe that it is ridiculous for anyone
>>>>>>>>> to ever
>>>>>>>>> consider defining a partial halt decider because everyone
>>>>>>>>> agrees that
>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>
>>>>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>
>>>>>> I see you don't dispute these facts.
>>>>
>>>> Good to see these facts confirmed by you once again.  If you dispute
>>>> that you justify giving the wrong answer using another related
>>>> computation, all you need to do is say so (and correct the record where
>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>> denote a finite computation).
>>>>
>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>
>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the
>>>>>> real one,
>>>>>> not the one you posted recently to poison the well)?  It calls no
>>>>>> functions that call H_Hat.  In the world of C and x86 code, that
>>>>>> means
>>>>>> it is not recursive at all.
>>>>
>>>>>> You ignored the key facts I put to you.  These were facts that you
>>>>>> told
>>>>>> me so you are stuck with them until you correct the record.
>>>>>
>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>>> cannot correctly refute this fact.
>>>>
>>>> I am not dodging it -- I am telling you it's a lie.  I started out
>>>> being
>>>> polite and technical, but it amounts to the same thing: if the trace
>>>> shows recursion, it is a fake.  The only clue you have given us at to
>>>> what Halts does made it plain that there is no recursive call, so the
>>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>>> in order to be able to show /something/ when you dare not show the
>>>> code.
>>>> If the trace shows a recursive call, it does not comport with what you
>>>> have published about Halts and that makes one or other of those (the
>>>> sketch of Halts or the trace) a plain deception.
>>>
>>> Actually, I am not sure I would call it a 'lie' but just a very
>>> different model of reality. From what I can infer from what we are told,
>>> x86utm is designed as a simulator/halt decider designed to handle
>>> systems with this sort of nested simulations.
>>>
>>> Halts is not really a 'function' in the normal sense, but an entry point
>>> into the simulator that converts the call to it to simulate/decide for a
>>> provided input into a real 'simulated' call with some book keeping.
>>
>> The best information we have about Halts (as far as I know) is a sketch
>> showing a loop that single-steps a simulation and a function call that
>> assesses whether to end the loop:
>>
>>    bool Halts(u32 P, u32 I)
>>    {
>>      bool Halted  = false;
>>      bool Aborted = false;
>>      while (!Halted && !Aborted)
>>      {
>>        Halted  = DebugStep(P, I);
>>        Aborted = Needs_To_Be_Aborted();
>>      }
>>      return !Aborted;
>>    }
>>
>> If the trace shows a recursive call, I'd call that a lie.  Something is
>> not as we've been led to believe.
>>
>> Mind you, I refuse to look at the trace, so I am going by what PO says
>> about it.  Have I misunderstood him?  Does it not show Halts(H_Hat,
>> H_Hat) making recursive calls?
>>
> 
> In the above case it only shows that actual execution trace of whatever
> is input, unless the input must be aborted.
> 
> Infinitely nested simulations match the [Infinite Recursion] dynamic
> behavior pattern, and the halt decider does not need to know the
> difference.
> 
> 

Except that it doesn't, as it omits code that is part of the
computation, namely the contents of the Halts called by H_Hat.

[toc] | [prev] | [next] | [standalone]


#32604 — 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-02 20:55 -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<XRHjI.67048$b27.14253@fx03.iad>
In reply to#32599
On 5/2/21 7:53 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>
>>>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>>>
>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>
>>>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>> H_Hat(H_Hat) is finite.
>>>>>
>>>>> I see you don't dispute these facts.
>>>
>>> Good to see these facts confirmed by you once again.  If you dispute
>>> that you justify giving the wrong answer using another related
>>> computation, all you need to do is say so (and correct the record where
>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>> denote a finite computation).
>>>
>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>
>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>> not the one you posted recently to poison the well)?  It calls no
>>>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>>>> it is not recursive at all.
>>>
>>>>> You ignored the key facts I put to you.  These were facts that you told
>>>>> me so you are stuck with them until you correct the record.  
>>>>
>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>> cannot correctly refute this fact.
>>>
>>> I am not dodging it -- I am telling you it's a lie.  I started out being
>>> polite and technical, but it amounts to the same thing: if the trace
>>> shows recursion, it is a fake.  The only clue you have given us at to
>>> what Halts does made it plain that there is no recursive call, so the
>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>> in order to be able to show /something/ when you dare not show the code.
>>> If the trace shows a recursive call, it does not comport with what you
>>> have published about Halts and that makes one or other of those (the
>>> sketch of Halts or the trace) a plain deception.
>>
>> Actually, I am not sure I would call it a 'lie' but just a very
>> different model of reality. From what I can infer from what we are told,
>> x86utm is designed as a simulator/halt decider designed to handle
>> systems with this sort of nested simulations.
>>
>> Halts is not really a 'function' in the normal sense, but an entry point
>> into the simulator that converts the call to it to simulate/decide for a
>> provided input into a real 'simulated' call with some book keeping.
> 
> The best information we have about Halts (as far as I know) is a sketch
> showing a loop that single-steps a simulation and a function call that
> assesses whether to end the loop:
> 
>   bool Halts(u32 P, u32 I)
>   {
>     bool Halted  = false;
>     bool Aborted = false;
>     while (!Halted && !Aborted)
>     {
>       Halted  = DebugStep(P, I);
>       Aborted = Needs_To_Be_Aborted();
>     }
>     return !Aborted;
>   }
> 
> If the trace shows a recursive call, I'd call that a lie.  Something is
> not as we've been led to believe.
> 
> Mind you, I refuse to look at the trace, so I am going by what PO says
> about it.  Have I misunderstood him?  Does it not show Halts(H_Hat,
> H_Hat) making recursive calls?
> 

Yes, he has provided that sketch for Halts, which actually implies if
you think about what he seems to be doing that at least DebugStep isn't
a computation, but an access to the bigger emulator with a lot of hidden
state.

It CAN'T be a simple computation, as something needs to be keeping track
of each step, and Needs_To_Be_aborted() doesn't have anything to make
its decision on.

This impies also that Halts isn't a Compuation either.

[toc] | [prev] | [next] | [standalone]


#32614 — 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 13:43 +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<87a6pc6l9m.fsf@bsb.me.uk>
In reply to#32604
Richard Damon <Richard@Damon-Family.org> writes:

> On 5/2/21 7:53 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>> 
>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>
>>>>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>>>>
>>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>
>>>>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>
>>>>>> I see you don't dispute these facts.
>>>>
>>>> Good to see these facts confirmed by you once again.  If you dispute
>>>> that you justify giving the wrong answer using another related
>>>> computation, all you need to do is say so (and correct the record where
>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>> denote a finite computation).
>>>>
>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>
>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>>> not the one you posted recently to poison the well)?  It calls no
>>>>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>>>>> it is not recursive at all.
>>>>
>>>>>> You ignored the key facts I put to you.  These were facts that you told
>>>>>> me so you are stuck with them until you correct the record.  
>>>>>
>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>>> cannot correctly refute this fact.
>>>>
>>>> I am not dodging it -- I am telling you it's a lie.  I started out being
>>>> polite and technical, but it amounts to the same thing: if the trace
>>>> shows recursion, it is a fake.  The only clue you have given us at to
>>>> what Halts does made it plain that there is no recursive call, so the
>>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>>> in order to be able to show /something/ when you dare not show the code.
>>>> If the trace shows a recursive call, it does not comport with what you
>>>> have published about Halts and that makes one or other of those (the
>>>> sketch of Halts or the trace) a plain deception.
>>>
>>> Actually, I am not sure I would call it a 'lie' but just a very
>>> different model of reality. From what I can infer from what we are told,
>>> x86utm is designed as a simulator/halt decider designed to handle
>>> systems with this sort of nested simulations.
>>>
>>> Halts is not really a 'function' in the normal sense, but an entry point
>>> into the simulator that converts the call to it to simulate/decide for a
>>> provided input into a real 'simulated' call with some book keeping.
>> 
>> The best information we have about Halts (as far as I know) is a sketch
>> showing a loop that single-steps a simulation and a function call that
>> assesses whether to end the loop:
>> 
>>   bool Halts(u32 P, u32 I)
>>   {
>>     bool Halted  = false;
>>     bool Aborted = false;
>>     while (!Halted && !Aborted)
>>     {
>>       Halted  = DebugStep(P, I);
>>       Aborted = Needs_To_Be_Aborted();
>>     }
>>     return !Aborted;
>>   }
>> 
>> If the trace shows a recursive call, I'd call that a lie.  Something is
>> not as we've been led to believe.
>> 
>> Mind you, I refuse to look at the trace, so I am going by what PO says
>> about it.  Have I misunderstood him?  Does it not show Halts(H_Hat,
>> H_Hat) making recursive calls?
>> 
>
> Yes, he has provided that sketch for Halts, which actually implies if
> you think about what he seems to be doing that at least DebugStep isn't
> a computation, but an access to the bigger emulator with a lot of hidden
> state.
>
> It CAN'T be a simple computation, as something needs to be keeping track
> of each step, and Needs_To_Be_aborted() doesn't have anything to make
> its decision on.

Of course it has state.  I think this concern about what is a simple
computation is a side issue.  This was posted in reply to a challenge of
mine to write a function F(p, i) that returns true if p(i) halts and
false otherwise.  All I said was that I would provide the confounding
case.

It does not matter how many side-effects Halts has, or what state it
uses or if it trawls the Internet for clues.  It is possible to come up
with any number of tricks that can get round the usual construction, but
it is always possible to generate a confounding case that defeats them.
Of course, to do that in the face of the most cunning opponent would
require access to the real source code, and not a sketch.

But PO is not cunning, he is just silly.  He was prepared to confirm
that, however it does it, Halts(Confound_Halts, Confound_Halts) returns
false, at the same time as confirming that arguments to Halts represent
a finite computation.  This is 100% in line with his prior posts about
re-defining the terms involved in the problem, AKA, ignoring the
problem.

He has always been delightfully clear about this nonsense.  False is
declared the correct answer for some halting computations because a
related computation (the one that "would not halt were it not halted")
justifies it.  Early on, he was even more clear.  False is correct
because of what happens when the Needs_To_Be_aborted line is commented
out.  I suspect he thought that was too crude, so the verbal gymnastics
started.

(His is also a liar in that he told Mike Terry, point blank, that Halts
always returns, and always with the same value when given the same
arguments, but then he told me that Halts does not always return a value
at all, but I don't think that trick is actually being used.  I can't
say, because all the detail are hidden from us.)

> This impies also that Halts isn't a Compuation either.

I was hoping you could say whether the trace shows recursive calls or
not rather then opening up the what is a computation on a messy system
like an x86!

If the trace shows recursive calls, then it doesn't comport with what he
said about Halts.  If it shows the correct nested simulation, then it
will either just confirm what Halts returns or it will show he was lying
about that.  And if he ever publishes a trace of the key computation
(H_Hat(H_Hat)) that will either show up some other lies or it will
confirm that Halts is indeed returning the wrong answer -- the answer PO
declares to be the right one.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#32616 — 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 09:06 -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<0aydnURwxLn1ng39nZ2dnUU7-QfNnZ2d@giganews.com>
In reply to#32614
On 5/3/2021 7:43 AM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> On 5/2/21 7:53 PM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>>
>>>>>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>>>>>
>>>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>>
>>>>>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>>
>>>>>>> I see you don't dispute these facts.
>>>>>
>>>>> Good to see these facts confirmed by you once again.  If you dispute
>>>>> that you justify giving the wrong answer using another related
>>>>> computation, all you need to do is say so (and correct the record where
>>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>>> denote a finite computation).
>>>>>
>>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>>
>>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>>>> not the one you posted recently to poison the well)?  It calls no
>>>>>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>>>>>> it is not recursive at all.
>>>>>
>>>>>>> You ignored the key facts I put to you.  These were facts that you told
>>>>>>> me so you are stuck with them until you correct the record.
>>>>>>
>>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>>>> cannot correctly refute this fact.
>>>>>
>>>>> I am not dodging it -- I am telling you it's a lie.  I started out being
>>>>> polite and technical, but it amounts to the same thing: if the trace
>>>>> shows recursion, it is a fake.  The only clue you have given us at to
>>>>> what Halts does made it plain that there is no recursive call, so the
>>>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>>>> in order to be able to show /something/ when you dare not show the code.
>>>>> If the trace shows a recursive call, it does not comport with what you
>>>>> have published about Halts and that makes one or other of those (the
>>>>> sketch of Halts or the trace) a plain deception.
>>>>
>>>> Actually, I am not sure I would call it a 'lie' but just a very
>>>> different model of reality. From what I can infer from what we are told,
>>>> x86utm is designed as a simulator/halt decider designed to handle
>>>> systems with this sort of nested simulations.
>>>>
>>>> Halts is not really a 'function' in the normal sense, but an entry point
>>>> into the simulator that converts the call to it to simulate/decide for a
>>>> provided input into a real 'simulated' call with some book keeping.
>>>
>>> The best information we have about Halts (as far as I know) is a sketch
>>> showing a loop that single-steps a simulation and a function call that
>>> assesses whether to end the loop:
>>>
>>>    bool Halts(u32 P, u32 I)
>>>    {
>>>      bool Halted  = false;
>>>      bool Aborted = false;
>>>      while (!Halted && !Aborted)
>>>      {
>>>        Halted  = DebugStep(P, I);
>>>        Aborted = Needs_To_Be_Aborted();
>>>      }
>>>      return !Aborted;
>>>    }
>>>
>>> If the trace shows a recursive call, I'd call that a lie.  Something is
>>> not as we've been led to believe.
>>>
>>> Mind you, I refuse to look at the trace, so I am going by what PO says
>>> about it.  Have I misunderstood him?  Does it not show Halts(H_Hat,
>>> H_Hat) making recursive calls?
>>>
>>
>> Yes, he has provided that sketch for Halts, which actually implies if
>> you think about what he seems to be doing that at least DebugStep isn't
>> a computation, but an access to the bigger emulator with a lot of hidden
>> state.
>>
>> It CAN'T be a simple computation, as something needs to be keeping track
>> of each step, and Needs_To_Be_aborted() doesn't have anything to make
>> its decision on.
> 
> Of course it has state.  I think this concern about what is a simple
> computation is a side issue.  This was posted in reply to a challenge of
> mine to write a function F(p, i) that returns true if p(i) halts and
> false otherwise.  All I said was that I would provide the confounding
> case.
> 
> It does not matter how many side-effects Halts has, or what state it
> uses or if it trawls the Internet for clues.  It is possible to come up
> with any number of tricks that can get round the usual construction, but
> it is always possible to generate a confounding case that defeats them.
> Of course, to do that in the face of the most cunning opponent would
> require access to the real source code, and not a sketch.
> 
> But PO is not cunning, he is just silly.  He was prepared to confirm
> that, however it does it, Halts(Confound_Halts, Confound_Halts) returns
> false, at the same time as confirming that arguments to Halts represent
> a finite computation.  This is 100% in line with his prior posts about
> re-defining the terms involved in the problem, AKA, ignoring the
> problem.
> 
> He has always been delightfully clear about this nonsense.  False is
> declared the correct answer for some halting computations because a
> related computation (the one that "would not halt were it not halted")
> justifies it.  Early on, he was even more clear.  False is correct
> because of what happens when the Needs_To_Be_aborted line is commented
> out.  I suspect he thought that was too crude, so the verbal gymnastics
> started.
> 
> (His is also a liar in that he told Mike Terry, point blank, that Halts
> always returns, and always with the same value when given the same
> arguments, but then he told me that Halts does not always return a value
> at all, but I don't think that trick is actually being used.  I can't
> say, because all the detail are hidden from us.)
> 
>> This impies also that Halts isn't a Compuation either.
> 
> I was hoping you could say whether the trace shows recursive calls or
> not rather then opening up the what is a computation on a messy system
> like an x86!
> 
> If the trace shows recursive calls, then it doesn't comport with what he
> said about Halts.  If it shows the correct nested simulation, then it
> will either just confirm what Halts returns or it will show he was lying
> about that.  And if he ever publishes a trace of the key computation
> (H_Hat(H_Hat)) that will either show up some other lies or it will
> confirm that Halts is indeed returning the wrong answer -- the answer PO
> declares to be the right one.
> 

The nested simulations are not invocations that must return they are 
data that is being processed by the halt decider.

_H_Hat()
[00000b1f](01)  55                      push ebp
[00000b20](02)  8bec                    mov ebp,esp
[00000b22](01)  51                      push ecx
[00000b23](03)  8b4508                  mov eax,[ebp+08]
[00000b26](01)  50                      push eax
[00000b27](03)  8b4d08                  mov ecx,[ebp+08]
[00000b2a](01)  51                      push ecx
[00000b2b](05)  e82ffeffff              call 0000095f
[00000b30](03)  83c408                  add esp,+08
[00000b33](03)  8945fc                  mov [ebp-04],eax
[00000b36](04)  837dfc00                cmp dword [ebp-04],+00
[00000b3a](02)  7402                    jz 00000b3e
[00000b3c](02)  ebfe                    jmp 00000b3c
[00000b3e](02)  8be5                    mov esp,ebp
[00000b40](01)  5d                      pop ebp
[00000b41](01)  c3                      ret
Size in bytes:(0035) [00000b41]

_main()
[00000b4f](01)  55                      push ebp
[00000b50](02)  8bec                    mov ebp,esp
[00000b52](01)  51                      push ecx
[00000b53](05)  681f0b0000              push 00000b1f
[00000b58](05)  681f0b0000              push 00000b1f
[00000b5d](05)  e8fdfdffff              call 0000095f
[00000b62](03)  83c408                  add esp,+08
[00000b65](03)  8945fc                  mov [ebp-04],eax
[00000b68](03)  8b45fc                  mov eax,[ebp-04]
[00000b6b](01)  50                      push eax
[00000b6c](05)  682b030000              push 0000032b
[00000b71](05)  e8e9f7ffff              call 0000035f
[00000b76](03)  83c408                  add esp,+08
[00000b79](02)  33c0                    xor eax,eax
[00000b7b](02)  8be5                    mov esp,ebp
[00000b7d](01)  5d                      pop ebp
[00000b7e](01)  c3                      ret
Size in bytes:(0048) [00000b7e]

Columns
(1) Machine address of instruction
(2) Machine address of top of stack
(3) Value of top of stack after instruction executed
(4) Number of bytes of machine code
(5) Machine language bytes
(6) Assembly language text

...[00000b4f][00101542][00000000](01)  55                      push ebp
...[00000b50][00101542][00000000](02)  8bec                    mov ebp,esp
...[00000b52][0010153e][00000000](01)  51                      push ecx
...[00000b53][0010153a][00000b1f](05)  681f0b0000              push 00000b1f
...[00000b58][00101536][00000b1f](05)  681f0b0000              push 00000b1f
...[00000b5d][00101532][00000b62](05)  e8fdfdffff              call 0000095f

Begin Local Halt Decider Simulation at Machine Address:b1f
...[00000b1f][002115e2][002115e6](01)  55                      push ebp
...[00000b20][002115e2][002115e6](02)  8bec                    mov ebp,esp
...[00000b22][002115de][002015b2](01)  51                      push ecx
...[00000b23][002115de][002015b2](03)  8b4508                  mov 
eax,[ebp+08]
...[00000b26][002115da][00000b1f](01)  50                      push eax
...[00000b27][002115da][00000b1f](03)  8b4d08                  mov 
ecx,[ebp+08]
...[00000b2a][002115d6][00000b1f](01)  51                      push ecx
...[00000b2b][002115d2][00000b30](05)  e82ffeffff              call 0000095f
The above eight instructions repeat

...[00000b1f][0025c00a][0025c00e](01)  55                      push ebp
...[00000b20][0025c00a][0025c00e](02)  8bec                    mov ebp,esp
...[00000b22][0025c006][0024bfda](01)  51                      push ecx
...[00000b23][0025c006][0024bfda](03)  8b4508                  mov 
eax,[ebp+08]
...[00000b26][0025c002][00000b1f](01)  50                      push eax
...[00000b27][0025c002][00000b1f](03)  8b4d08                  mov 
ecx,[ebp+08]
...[00000b2a][0025bffe][00000b1f](01)  51                      push ecx
...[00000b2b][0025bffa][00000b30](05)  e82ffeffff              call 0000095f
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
Infinite recursion detection criteria has been met

...[00000b62][0010153e][00000000](03)  83c408                  add esp,+08
...[00000b65][0010153e][00000000](03)  8945fc                  mov 
[ebp-04],eax
...[00000b68][0010153e][00000000](03)  8b45fc                  mov 
eax,[ebp-04]
...[00000b6b][0010153a][00000000](01)  50                      push eax
...[00000b6c][00101536][0000032b](05)  682b030000              push 0000032b
...[00000b71][00101532][00000b76](05)  e8e9f7ffff              call 0000035f
Input_Would_Halt = 0
...[00000b76][0010153e][00000000](03)  83c408                  add esp,+08
...[00000b79][0010153e][00000000](02)  33c0                    xor eax,eax
...[00000b7b][00101542][00000000](02)  8be5                    mov esp,ebp
...[00000b7d][00101546][00100000](01)  5d                      pop ebp
...[00000b7e][0010154a][00000080](01)  c3                      ret
Number_of_User_Instructions(33)
Number of Instructions Executed(26560)

All calls from H_Hat() to Halts() match the [Infinite Recursion] dynamic 
behavior pattern.
If the execution trace of H_Hat() by function Halts() shows:
(1) Function Halts() is called twice in sequence from the same machine 
address of H_Hat().
(2) With the same parameters to Halts().
(3) With no conditional branch or indexed jump instructions in H_Hat().
(4) With no function call returns from Halts().
then the function call from H_Hat() to Halts() is infinitely recursive.

It is ridiculously simple to see that H_Hat() does match the [Infinite 
Recursion] dynamic behavior pattern of non halting behavior. That you 
continue to deny this seems utterly foolish.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#32619 — 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 10:34 -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<JRTjI.418431$nn2.47149@fx48.iad>
In reply to#32616
On 5/3/21 10:06 AM, olcott wrote:
> On 5/3/2021 7:43 AM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> On 5/2/21 7:53 PM, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its
>>>>>>>>>>>>> otherwise
>>>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>>>
>>>>>>>>>>>> This is just a silly word game.  What a computation would do
>>>>>>>>>>>> "otherwise"
>>>>>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not
>>>>>>>>>>>> matter how or
>>>>>>>>>>>> why.  It is a finite computation, and should be reported as
>>>>>>>>>>>> such.
>>>>>>>>>>>
>>>>>>>>>>> So in other words you believe that it is ridiculous for
>>>>>>>>>>> anyone to ever
>>>>>>>>>>> consider defining a partial halt decider because everyone
>>>>>>>>>>> agrees that
>>>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>>>
>>>>>>>>>> No.  I am saying that your wording is silly because it
>>>>>>>>>> attempts to
>>>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>>>
>>>>>>>> I see you don't dispute these facts.
>>>>>>
>>>>>> Good to see these facts confirmed by you once again.  If you dispute
>>>>>> that you justify giving the wrong answer using another related
>>>>>> computation, all you need to do is say so (and correct the record
>>>>>> where
>>>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>>>> denote a finite computation).
>>>>>>
>>>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>>>
>>>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the
>>>>>>>> real one,
>>>>>>>> not the one you posted recently to poison the well)?  It calls no
>>>>>>>> functions that call H_Hat.  In the world of C and x86 code, that
>>>>>>>> means
>>>>>>>> it is not recursive at all.
>>>>>>
>>>>>>>> You ignored the key facts I put to you.  These were facts that
>>>>>>>> you told
>>>>>>>> me so you are stuck with them until you correct the record.
>>>>>>>
>>>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>>>> above criteria of infinite recursion, you can dodge this fact but
>>>>>>> you
>>>>>>> cannot correctly refute this fact.
>>>>>>
>>>>>> I am not dodging it -- I am telling you it's a lie.  I started out
>>>>>> being
>>>>>> polite and technical, but it amounts to the same thing: if the trace
>>>>>> shows recursion, it is a fake.  The only clue you have given us at to
>>>>>> what Halts does made it plain that there is no recursive call, so the
>>>>>> trace you show is, as far anyone can tell, a fiction, a lie,
>>>>>> published
>>>>>> in order to be able to show /something/ when you dare not show the
>>>>>> code.
>>>>>> If the trace shows a recursive call, it does not comport with what
>>>>>> you
>>>>>> have published about Halts and that makes one or other of those (the
>>>>>> sketch of Halts or the trace) a plain deception.
>>>>>
>>>>> Actually, I am not sure I would call it a 'lie' but just a very
>>>>> different model of reality. From what I can infer from what we are
>>>>> told,
>>>>> x86utm is designed as a simulator/halt decider designed to handle
>>>>> systems with this sort of nested simulations.
>>>>>
>>>>> Halts is not really a 'function' in the normal sense, but an entry
>>>>> point
>>>>> into the simulator that converts the call to it to simulate/decide
>>>>> for a
>>>>> provided input into a real 'simulated' call with some book keeping.
>>>>
>>>> The best information we have about Halts (as far as I know) is a sketch
>>>> showing a loop that single-steps a simulation and a function call that
>>>> assesses whether to end the loop:
>>>>
>>>>    bool Halts(u32 P, u32 I)
>>>>    {
>>>>      bool Halted  = false;
>>>>      bool Aborted = false;
>>>>      while (!Halted && !Aborted)
>>>>      {
>>>>        Halted  = DebugStep(P, I);
>>>>        Aborted = Needs_To_Be_Aborted();
>>>>      }
>>>>      return !Aborted;
>>>>    }
>>>>
>>>> If the trace shows a recursive call, I'd call that a lie.  Something is
>>>> not as we've been led to believe.
>>>>
>>>> Mind you, I refuse to look at the trace, so I am going by what PO says
>>>> about it.  Have I misunderstood him?  Does it not show Halts(H_Hat,
>>>> H_Hat) making recursive calls?
>>>>
>>>
>>> Yes, he has provided that sketch for Halts, which actually implies if
>>> you think about what he seems to be doing that at least DebugStep isn't
>>> a computation, but an access to the bigger emulator with a lot of hidden
>>> state.
>>>
>>> It CAN'T be a simple computation, as something needs to be keeping track
>>> of each step, and Needs_To_Be_aborted() doesn't have anything to make
>>> its decision on.
>>
>> Of course it has state.  I think this concern about what is a simple
>> computation is a side issue.  This was posted in reply to a challenge of
>> mine to write a function F(p, i) that returns true if p(i) halts and
>> false otherwise.  All I said was that I would provide the confounding
>> case.
>>
>> It does not matter how many side-effects Halts has, or what state it
>> uses or if it trawls the Internet for clues.  It is possible to come up
>> with any number of tricks that can get round the usual construction, but
>> it is always possible to generate a confounding case that defeats them.
>> Of course, to do that in the face of the most cunning opponent would
>> require access to the real source code, and not a sketch.
>>
>> But PO is not cunning, he is just silly.  He was prepared to confirm
>> that, however it does it, Halts(Confound_Halts, Confound_Halts) returns
>> false, at the same time as confirming that arguments to Halts represent
>> a finite computation.  This is 100% in line with his prior posts about
>> re-defining the terms involved in the problem, AKA, ignoring the
>> problem.
>>
>> He has always been delightfully clear about this nonsense.  False is
>> declared the correct answer for some halting computations because a
>> related computation (the one that "would not halt were it not halted")
>> justifies it.  Early on, he was even more clear.  False is correct
>> because of what happens when the Needs_To_Be_aborted line is commented
>> out.  I suspect he thought that was too crude, so the verbal gymnastics
>> started.
>>
>> (His is also a liar in that he told Mike Terry, point blank, that Halts
>> always returns, and always with the same value when given the same
>> arguments, but then he told me that Halts does not always return a value
>> at all, but I don't think that trick is actually being used.  I can't
>> say, because all the detail are hidden from us.)
>>
>>> This impies also that Halts isn't a Compuation either.
>>
>> I was hoping you could say whether the trace shows recursive calls or
>> not rather then opening up the what is a computation on a messy system
>> like an x86!
>>
>> If the trace shows recursive calls, then it doesn't comport with what he
>> said about Halts.  If it shows the correct nested simulation, then it
>> will either just confirm what Halts returns or it will show he was lying
>> about that.  And if he ever publishes a trace of the key computation
>> (H_Hat(H_Hat)) that will either show up some other lies or it will
>> confirm that Halts is indeed returning the wrong answer -- the answer PO
>> declares to be the right one.
>>
> 
> The nested simulations are not invocations that must return they are
> data that is being processed by the halt decider.

Then why do you trace them as if they were?

> 
> _H_Hat()
> [00000b1f](01)  55                      push ebp
> [00000b20](02)  8bec                    mov ebp,esp
> [00000b22](01)  51                      push ecx
> [00000b23](03)  8b4508                  mov eax,[ebp+08]
> [00000b26](01)  50                      push eax
> [00000b27](03)  8b4d08                  mov ecx,[ebp+08]
> [00000b2a](01)  51                      push ecx
> [00000b2b](05)  e82ffeffff              call 0000095f
> [00000b30](03)  83c408                  add esp,+08
> [00000b33](03)  8945fc                  mov [ebp-04],eax
> [00000b36](04)  837dfc00                cmp dword [ebp-04],+00
> [00000b3a](02)  7402                    jz 00000b3e
> [00000b3c](02)  ebfe                    jmp 00000b3c
> [00000b3e](02)  8be5                    mov esp,ebp
> [00000b40](01)  5d                      pop ebp
> [00000b41](01)  c3                      ret
> Size in bytes:(0035) [00000b41]
> 
> _main()
> [00000b4f](01)  55                      push ebp
> [00000b50](02)  8bec                    mov ebp,esp
> [00000b52](01)  51                      push ecx
> [00000b53](05)  681f0b0000              push 00000b1f
> [00000b58](05)  681f0b0000              push 00000b1f
> [00000b5d](05)  e8fdfdffff              call 0000095f
> [00000b62](03)  83c408                  add esp,+08
> [00000b65](03)  8945fc                  mov [ebp-04],eax
> [00000b68](03)  8b45fc                  mov eax,[ebp-04]
> [00000b6b](01)  50                      push eax
> [00000b6c](05)  682b030000              push 0000032b
> [00000b71](05)  e8e9f7ffff              call 0000035f
> [00000b76](03)  83c408                  add esp,+08
> [00000b79](02)  33c0                    xor eax,eax
> [00000b7b](02)  8be5                    mov esp,ebp
> [00000b7d](01)  5d                      pop ebp
> [00000b7e](01)  c3                      ret
> Size in bytes:(0048) [00000b7e]
> 
> Columns
> (1) Machine address of instruction
> (2) Machine address of top of stack
> (3) Value of top of stack after instruction executed
> (4) Number of bytes of machine code
> (5) Machine language bytes
> (6) Assembly language text
> 
> ...[00000b4f][00101542][00000000](01)  55                      push ebp
> ...[00000b50][00101542][00000000](02)  8bec                    mov ebp,esp
> ...[00000b52][0010153e][00000000](01)  51                      push ecx
> ...[00000b53][0010153a][00000b1f](05)  681f0b0000              push
> 00000b1f
> ...[00000b58][00101536][00000b1f](05)  681f0b0000              push
> 00000b1f
> ...[00000b5d][00101532][00000b62](05)  e8fdfdffff              call
> 0000095f
> 
> Begin Local Halt Decider Simulation at Machine Address:b1f
> ...[00000b1f][002115e2][002115e6](01)  55                      push ebp
> ...[00000b20][002115e2][002115e6](02)  8bec                    mov ebp,esp
> ...[00000b22][002115de][002015b2](01)  51                      push ecx
> ...[00000b23][002115de][002015b2](03)  8b4508                  mov
> eax,[ebp+08]
> ...[00000b26][002115da][00000b1f](01)  50                      push eax
> ...[00000b27][002115da][00000b1f](03)  8b4d08                  mov
> ecx,[ebp+08]
> ...[00000b2a][002115d6][00000b1f](01)  51                      push ecx
> ...[00000b2b][002115d2][00000b30](05)  e82ffeffff              call
> 0000095f
> The above eight instructions repeat
> 
> ...[00000b1f][0025c00a][0025c00e](01)  55                      push ebp
> ...[00000b20][0025c00a][0025c00e](02)  8bec                    mov ebp,esp
> ...[00000b22][0025c006][0024bfda](01)  51                      push ecx
> ...[00000b23][0025c006][0024bfda](03)  8b4508                  mov
> eax,[ebp+08]
> ...[00000b26][0025c002][00000b1f](01)  50                      push eax
> ...[00000b27][0025c002][00000b1f](03)  8b4d08                  mov
> ecx,[ebp+08]
> ...[00000b2a][0025bffe][00000b1f](01)  51                      push ecx
> ...[00000b2b][0025bffa][00000b30](05)  e82ffeffff              call
> 0000095f
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> Infinite recursion detection criteria has been met
> 
> ...[00000b62][0010153e][00000000](03)  83c408                  add esp,+08
> ...[00000b65][0010153e][00000000](03)  8945fc                  mov
> [ebp-04],eax
> ...[00000b68][0010153e][00000000](03)  8b45fc                  mov
> eax,[ebp-04]
> ...[00000b6b][0010153a][00000000](01)  50                      push eax
> ...[00000b6c][00101536][0000032b](05)  682b030000              push
> 0000032b
> ...[00000b71][00101532][00000b76](05)  e8e9f7ffff              call
> 0000035f
> Input_Would_Halt = 0
> ...[00000b76][0010153e][00000000](03)  83c408                  add esp,+08
> ...[00000b79][0010153e][00000000](02)  33c0                    xor eax,eax
> ...[00000b7b][00101542][00000000](02)  8be5                    mov esp,ebp
> ...[00000b7d][00101546][00100000](01)  5d                      pop ebp
> ...[00000b7e][0010154a][00000080](01)  c3                      ret
> Number_of_User_Instructions(33)
> Number of Instructions Executed(26560)
> 
> All calls from H_Hat() to Halts() match the [Infinite Recursion] dynamic
> behavior pattern.
> If the execution trace of H_Hat() by function Halts() shows:
> (1) Function Halts() is called twice in sequence from the same machine
> address of H_Hat().
> (2) With the same parameters to Halts().
> (3) With no conditional branch or indexed jump instructions in H_Hat().
> (4) With no function call returns from Halts().
> then the function call from H_Hat() to Halts() is infinitely recursive.
> 
> It is ridiculously simple to see that H_Hat() does match the [Infinite
> Recursion] dynamic behavior pattern of non halting behavior. That you
> continue to deny this seems utterly foolish.
> 

And that rule is flawed, as the conditionals inside the 'call' to Halts
within H_Hat are PART of the Computation of H_Hat, and thus its decision
(or ability to decide) is part of H_Hat, which the outer Halts does not
take into account.

Your trace is flawed, as you don't trace the simulation of the code of
Halts, but switch to the trace that it is simulating. That is an
incorrect operation.

The outer trace from Halts should show a tracing of what the call to
Halts in H_Hat actually does, as THAT is what the outer Halts should be
simulating. By 'taking over' the simulation it has conflated its own
simulation with that of the code inside H_Hat.

[toc] | [prev] | [next] | [standalone]


#32660 — 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:58 +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<87y2cv4bfl.fsf@bsb.me.uk>
In reply to#32616
olcott <NoOne@NoWhere.com> writes:

> It is ridiculously simple to see that H_Hat() does match the [Infinite
> Recursion] dynamic behavior pattern of non halting behavior. That you
> continue to deny this seems utterly foolish.

You are very confused about what other people think.  I would never
comment on whether some code I have never seen conforms to some pattern
you have given a silly name to.  Especially as you have described this
pattern using, apparently, the wrong words.  You talk about recursive
calls and I believe that to be, at best, a misuse of language.

I know that halts must detect /something/ that it can use to give the
wrong answer but I don't really care what it is detecting (and I
certainly don't care what you've decided to call it) because it can't
justify the wrong answer:

(a) Halts(H_Hat, H_Hat) is false, but
(b) the arguments to false represent and finite computation.

You simply declare the wrong answer to be the right one.  Simples!

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#32671 — 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:12 -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-dneetWMrS-Qz9nZ2dnUU7-ROdnZ2d@giganews.com>
In reply to#32660
On 5/3/2021 6:58 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> It is ridiculously simple to see that H_Hat() does match the [Infinite
>> Recursion] dynamic behavior pattern of non halting behavior. That you
>> continue to deny this seems utterly foolish.
> 
> You are very confused about what other people think.  I would never
> comment on whether some code I have never seen conforms to some pattern
> you have given a silly name to.  Especially as you have described this
> pattern using, apparently, the wrong words.  You talk about recursive
> calls and I believe that to be, at best, a misuse of language.
> 
> I know that halts must detect /something/ that it can use to give the
> wrong answer but I don't really care what it is detecting (and I
> certainly don't care what you've decided to call it) because it can't
> justify the wrong answer:
> 
> (a) Halts(H_Hat, H_Hat) is false, but
> (b) the arguments to false represent and finite computation.
> 
> You simply declare the wrong answer to be the right one.  Simples!
> 

Do you understand the generic idea that non halting behavior could be 
detected when this behavior matches a non-halting dynamic behavior pattern?

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#32707 — 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:57 +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<87tuni2p5j.fsf@bsb.me.uk>
In reply to#32671
olcott <NoOne@NoWhere.com> writes:

> On 5/3/2021 6:58 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> It is ridiculously simple to see that H_Hat() does match the [Infinite
>>> Recursion] dynamic behavior pattern of non halting behavior. That you
>>> continue to deny this seems utterly foolish.
>>
>> You are very confused about what other people think.  I would never
>> comment on whether some code I have never seen conforms to some pattern
>> you have given a silly name to.  Especially as you have described this
>> pattern using, apparently, the wrong words.  You talk about recursive
>> calls and I believe that to be, at best, a misuse of language.
>>
>> I know that halts must detect /something/ that it can use to give the
>> wrong answer but I don't really care what it is detecting (and I
>> certainly don't care what you've decided to call it) because it can't
>> justify the wrong answer:
>>
>> (a) Halts(H_Hat, H_Hat) is false, but
>> (b) the arguments to false represent and finite computation.
>>
>> You simply declare the wrong answer to be the right one.  Simples!
>
> Do you understand the generic idea that non halting behavior could be
> detected when this behavior matches a non-halting dynamic behavior
> pattern?

Of course.

Do you understand that false is the wrong answer for Halts to give when
the arguments to Halts denote a computation that is finite?

Try to give as honest and direct an answer as you can.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


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

FromJeff Barnett <jbb@notatt.com>
Date2021-05-03 11:39 -0600
SubjectRe: Mutual agreement on the definition of a [computation] in computer science [ H_Hat() ALWAYS specifies infinite recursion that must be aborted ]
Message-ID<s6pcgd$d21$1@dont-email.me>
In reply to#32614
On 5/3/2021 6:43 AM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> On 5/2/21 7:53 PM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> On 5/2/21 4:38 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>>>
>>>>>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>>>>>
>>>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>>>
>>>>>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>>>> H_Hat(H_Hat) is finite.
>>>>>>>
>>>>>>> I see you don't dispute these facts.
>>>>>
>>>>> Good to see these facts confirmed by you once again.  If you dispute
>>>>> that you justify giving the wrong answer using another related
>>>>> computation, all you need to do is say so (and correct the record where
>>>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>>>> denote a finite computation).
>>>>>
>>>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>>>
>>>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>>>> not the one you posted recently to poison the well)?  It calls no
>>>>>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>>>>>> it is not recursive at all.
>>>>>
>>>>>>> You ignored the key facts I put to you.  These were facts that you told
>>>>>>> me so you are stuck with them until you correct the record.
>>>>>>
>>>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>>>> cannot correctly refute this fact.
>>>>>
>>>>> I am not dodging it -- I am telling you it's a lie.  I started out being
>>>>> polite and technical, but it amounts to the same thing: if the trace
>>>>> shows recursion, it is a fake.  The only clue you have given us at to
>>>>> what Halts does made it plain that there is no recursive call, so the
>>>>> trace you show is, as far anyone can tell, a fiction, a lie, published
>>>>> in order to be able to show /something/ when you dare not show the code.
>>>>> If the trace shows a recursive call, it does not comport with what you
>>>>> have published about Halts and that makes one or other of those (the
>>>>> sketch of Halts or the trace) a plain deception.
>>>>
>>>> Actually, I am not sure I would call it a 'lie' but just a very
>>>> different model of reality. From what I can infer from what we are told,
>>>> x86utm is designed as a simulator/halt decider designed to handle
>>>> systems with this sort of nested simulations.
>>>>
>>>> Halts is not really a 'function' in the normal sense, but an entry point
>>>> into the simulator that converts the call to it to simulate/decide for a
>>>> provided input into a real 'simulated' call with some book keeping.
>>>
>>> The best information we have about Halts (as far as I know) is a sketch
>>> showing a loop that single-steps a simulation and a function call that
>>> assesses whether to end the loop:
>>>
>>>    bool Halts(u32 P, u32 I)
>>>    {
>>>      bool Halted  = false;
>>>      bool Aborted = false;
>>>      while (!Halted && !Aborted)
>>>      {
>>>        Halted  = DebugStep(P, I);
>>>        Aborted = Needs_To_Be_Aborted();
>>>      }
>>>      return !Aborted;
>>>    }
>>>
>>> If the trace shows a recursive call, I'd call that a lie.  Something is
>>> not as we've been led to believe.
>>>
>>> Mind you, I refuse to look at the trace, so I am going by what PO says
>>> about it.  Have I misunderstood him?  Does it not show Halts(H_Hat,
>>> H_Hat) making recursive calls?
>>>
>>
>> Yes, he has provided that sketch for Halts, which actually implies if
>> you think about what he seems to be doing that at least DebugStep isn't
>> a computation, but an access to the bigger emulator with a lot of hidden
>> state.
>>
>> It CAN'T be a simple computation, as something needs to be keeping track
>> of each step, and Needs_To_Be_aborted() doesn't have anything to make
>> its decision on.
> 
> Of course it has state.  I think this concern about what is a simple
> computation is a side issue.  This was posted in reply to a challenge of
> mine to write a function F(p, i) that returns true if p(i) halts and
> false otherwise.  All I said was that I would provide the confounding
> case.
> 
> It does not matter how many side-effects Halts has, or what state it
> uses or if it trawls the Internet for clues.  It is possible to come up
> with any number of tricks that can get round the usual construction, but
> it is always possible to generate a confounding case that defeats them.
> Of course, to do that in the face of the most cunning opponent would
> require access to the real source code, and not a sketch.

There is a precedent for that need in the world of computer security: 
When one wanted to test the vulnerability of supposed secure systems - 
usually operating systems - the "crackers" were always given the source 
code, etc. It was assumed that any serious opponent - usually an 
adversary nation state - would have made covert arrangements to obtain 
the same. Trying to develop a reliable crack for a complex black (or 
dark grey) box from the outside was recognized early on as a mostly 
futile activity.

In the current enterprise the claim is that given an H with a particular 
property one can find an application where the claim is false. Since 
such a claim is parameterized by H, the definition of H is necessary to 
actually state a particular claim. It is quite fortunate that there is a 
constructive proof scheme that may be applied to each H to show the 
claim is false. If this were not the case, the halting problem might 
still be an issue.

> But PO is not cunning, he is just silly.  He was prepared to confirm
> that, however it does it, Halts(Confound_Halts, Confound_Halts) returns
> false, at the same time as confirming that arguments to Halts represent
> a finite computation.  This is 100% in line with his prior posts about
> re-defining the terms involved in the problem, AKA, ignoring the
> problem.
> 
> He has always been delightfully clear about this nonsense.  False is
> declared the correct answer for some halting computations because a
> related computation (the one that "would not halt were it not halted")
> justifies it.  Early on, he was even more clear.  False is correct
> because of what happens when the Needs_To_Be_aborted line is commented
> out.  I suspect he thought that was too crude, so the verbal gymnastics
> started.
> 
> (His is also a liar in that he told Mike Terry, point blank, that Halts
> always returns, and always with the same value when given the same
> arguments, but then he told me that Halts does not always return a value
> at all, but I don't think that trick is actually being used.  I can't
> say, because all the detail are hidden from us.)
> 
>> This impies also that Halts isn't a Compuation either.
> 
> I was hoping you could say whether the trace shows recursive calls or
> not rather then opening up the what is a computation on a messy system
> like an x86!
> 
> If the trace shows recursive calls, then it doesn't comport with what he
> said about Halts.  If it shows the correct nested simulation, then it
> will either just confirm what Halts returns or it will show he was lying
> about that.  And if he ever publishes a trace of the key computation
> (H_Hat(H_Hat)) that will either show up some other lies or it will
> confirm that Halts is indeed returning the wrong answer -- the answer PO
> declares to be the right one.
-- 
Jeff Barnett

[toc] | [prev] | [next] | [standalone]


#32596 — 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-02 17:41 -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<_f2dnUajsvEUtxL9nZ2dnUU7-cPNnZ2d@giganews.com>
In reply to#32592
On 5/2/2021 3:38 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>
>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>
>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>
>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>> justify the wrong answer using another, different, computation.
>>>>> H_Hat(H_Hat) is finite.
>>>
>>> I see you don't dispute these facts.
> 
> Good to see these facts confirmed by you once again.  If you dispute
> that you justify giving the wrong answer using another related
> computation, all you need to do is say so (and correct the record where
> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
> denote a finite computation).
> 
>>>> The above criteria does correctly decide infinite recursion.
>>>
>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>> not the one you posted recently to poison the well)?  It calls no
>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>> it is not recursive at all.
> 
>>> You ignored the key facts I put to you.  These were facts that you told
>>> me so you are stuck with them until you correct the record.
>>
>> The key fact is that every time H_Hat() calls Halts() it meets the
>> above criteria of infinite recursion, you can dodge this fact but you
>> cannot correctly refute this fact.
> 
> I am not dodging it -- I am telling you it's a lie.  

You can even tell me that it is a lie, what you cannot do is prove that 
it is false.

> I started out being
> polite and technical, but it amounts to the same thing: if the trace
> shows recursion, it is a fake.  


void H_Hat2(u32 P)
{
   u32 Input_Would_Halt = Simulate(P, P);
}

int main()
{
   u32 Input_Would_Halt = Halts((u32)H_Hat2, (u32)H_Hat2);
}

In other words you are saying that the above is not computationally 
equivalent to infinite recursion.

> The only clue you have given us at to
> what Halts does made it plain that there is no recursive call, so the

Computationally equivalent to a recursive call is you insistent on being 
so damned (condemned to Hell) nit picky.

> trace you show is, as far anyone can tell, a fiction, a lie, published

It can be very easily verified as necessarily correct on the basis of 
the provided disassembled x86 code. The x86 source code proves that 
H_Hat() would do exactly what its execution trace shows that it does.

> in order to be able to show /something/ when you dare not show the code.
> If the trace shows a recursive call, it does not comport with what you
> have published about Halts and that makes one or other of those (the
> sketch of Halts or the trace) a plain deception.
> 

I need not show the code of Halts(), anyone can understand that it is an 
x86 emulator that does correctly match certain dynamic patterns of non 
halting behavior on the basis of this paper:

http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#32598 — 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 00:52 +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<87im407kxf.fsf@bsb.me.uk>
In reply to#32596
olcott <NoOne@NoWhere.com> writes:

> On 5/2/2021 3:38 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>
>>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>>
>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>
>>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>>> justify the wrong answer using another, different, computation.
>>>>>> H_Hat(H_Hat) is finite.
>>>>
>>>> I see you don't dispute these facts.
>>
>> Good to see these facts confirmed by you once again.  If you dispute
>> that you justify giving the wrong answer using another related
>> computation, all you need to do is say so (and correct the record where
>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>> denote a finite computation).

I think we can safely assume that you do not want to dispute any of
these facts.

>>>>> The above criteria does correctly decide infinite recursion.
>>>>
>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>> not the one you posted recently to poison the well)?  It calls no
>>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>>> it is not recursive at all.
>>
>>>> You ignored the key facts I put to you.  These were facts that you told
>>>> me so you are stuck with them until you correct the record.
>>>
>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>> above criteria of infinite recursion, you can dodge this fact but you
>>> cannot correctly refute this fact.
>>
>> I am not dodging it -- I am telling you it's a lie.  
>
> You can even tell me that it is a lie, what you cannot do is prove
> that it is false.

I don't know what that means.  I take what you say about the trace at
face value because I don't want to look at it without knowing what's
being traced.  You appear to be suggesting that the trace shows
recursive calls where there should be none.  I am happy to be corrected
on this point.  Does the trace show infinite nested simulations instead?

>> I started out being
>> polite and technical, but it amounts to the same thing: if the trace
>> shows recursion, it is a fake.  
>
> void H_Hat2(u32 P)
> {
>   u32 Input_Would_Halt = Simulate(P, P);
> }
>
> int main()
> {
>   u32 Input_Would_Halt = Halts((u32)H_Hat2, (u32)H_Hat2);
> }
>
> In other words you are saying that the above is not computationally
> equivalent to infinite recursion.

What a mess.  More code missing in action.  More odd phrases.  My best
guess at what "computationally equivalent to infinite recursion" means
is simply any non-finite computation.  So if you will just confirm that
Halts never returns to main, than I can actually agree -- the above is
"computationally equivalent to infinite recursion".

However, that is not my understanding of what one of the mystery
functions does.  I understood that Halts /does/ return to main.

>> The only clue you have given us at to
>> what Halts does made it plain that there is no recursive call, so the
>
> Computationally equivalent to a recursive call is you insistent on
> being so damned (condemned to Hell) nit picky.

I know what "computationally equivalent" means but it makes no sense
when joined with "to a recursive call".

I think you are agreeing that there are no recursive calls.  But doesn't
the trace show that there are?  I thought it did.

By the way, I can also to "big picture" stuff.  I don't always nit-pick.
See, for example, the text at the very top where, by not objecting, you
are implicitly agreeing by high-level summary of what you doing.

> I need not show the code of Halts(),

Well you /should/.  But I accept that you mustn't in order to keep
stringing people along.  After all, it's the chatting you like.

> http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf

That paper clearly says that you are talking about recursive calls.  In
other words, that paper uses the language correctly, and I assume the
trace shows recursive calls as well.  This suggests that either the
trace is fake or Halts is not at all as you described it last year.  Or
maybe the paper uses the wrong words.  Something is screwey.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#32600 — 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-02 19:34 -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<yqudnQROUq5-2RL9nZ2dnUU7-VnNnZ2d@giganews.com>
In reply to#32598
On 5/2/2021 6:52 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 5/2/2021 3:38 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 5/1/2021 9:30 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 5/1/2021 8:20 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 5/1/2021 7:51 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> No H_Hat() in the universe ever stops running unless its otherwise
>>>>>>>>>> infinite recursion is aborted at some point.
>>>>>>>>>
>>>>>>>>> This is just a silly word game.  What a computation would do "otherwise"
>>>>>>>>> is irrelevant.  H_Hat(H_Hat) is finite and it does not matter how or
>>>>>>>>> why.  It is a finite computation, and should be reported as such.
>>>>>>>>
>>>>>>>> So in other words you believe that it is ridiculous for anyone to ever
>>>>>>>> consider defining a partial halt decider because everyone agrees that
>>>>>>>> is cannot be done perfectly so why bother doing this at all.
>>>>>>>
>>>>>>> No.  I am saying that your wording is silly because it attempts to
>>>>>>> justify the wrong answer using another, different, computation.
>>>>>>> H_Hat(H_Hat) is finite.
>>>>>
>>>>> I see you don't dispute these facts.
>>>
>>> Good to see these facts confirmed by you once again.  If you dispute
>>> that you justify giving the wrong answer using another related
>>> computation, all you need to do is say so (and correct the record where
>>> you say that Halts(H_Hat, H_Hat) is false, but the arguments to Halts
>>> denote a finite computation).
> 
> I think we can safely assume that you do not want to dispute any of
> these facts.
> 
>>>>>> The above criteria does correctly decide infinite recursion.
>>>>>
>>>>> What has this got to do with the computation H_Hat(H_Hat) (the real one,
>>>>> not the one you posted recently to poison the well)?  It calls no
>>>>> functions that call H_Hat.  In the world of C and x86 code, that means
>>>>> it is not recursive at all.
>>>
>>>>> You ignored the key facts I put to you.  These were facts that you told
>>>>> me so you are stuck with them until you correct the record.
>>>>
>>>> The key fact is that every time H_Hat() calls Halts() it meets the
>>>> above criteria of infinite recursion, you can dodge this fact but you
>>>> cannot correctly refute this fact.
>>>
>>> I am not dodging it -- I am telling you it's a lie.
>>
>> You can even tell me that it is a lie, what you cannot do is prove
>> that it is false.
> 
> I don't know what that means.  I take what you say about the trace at
> face value because I don't want to look at it without knowing what's
> being traced.  You appear to be suggesting that the trace shows
> recursive calls where there should be none.  I am happy to be corrected
> on this point.  Does the trace show infinite nested simulations instead?
> 

Since the halt deciding criteria that matches infinite recursion is 
exactly the same as the criteria that matches infinite nested 
simulations and infinite nested simulations are computationally 
equivalent to infinite recursion I can them both infinite recursion.

The halt decider knows nothing about infinitely nested simulations it 
only knows that its infinite recursion dynamic behavior pattern has been 
matched.

>>> I started out being
>>> polite and technical, but it amounts to the same thing: if the trace
>>> shows recursion, it is a fake.
>>
>> void H_Hat2(u32 P)
>> {
>>    u32 Input_Would_Halt = Simulate(P, P);
>> }
>>
>> int main()
>> {
>>    u32 Input_Would_Halt = Halts((u32)H_Hat2, (u32)H_Hat2);
>> }
>>
>> In other words you are saying that the above is not computationally
>> equivalent to infinite recursion.
> 
> What a mess.  More code missing in action.  More odd phrases.  My best
> guess at what "computationally equivalent to infinite recursion" means
> is simply any non-finite computation.  

It is a specific dynamic behavior pattern that the halt decider has 
matched. It only distinguishes between infinite recursion and infinite 
loops.

> So if you will just confirm that
> Halts never returns to main, than I can actually agree -- the above is
> "computationally equivalent to infinite recursion".
> 
> However, that is not my understanding of what one of the mystery
> functions does.  I understood that Halts /does/ return to main.
> 
>>> The only clue you have given us at to
>>> what Halts does made it plain that there is no recursive call, so the
>>
>> Computationally equivalent to a recursive call is you insistent on
>> being so damned (condemned to Hell) nit picky.
> 
> I know what "computationally equivalent" means but it makes no sense
> when joined with "to a recursive call".
> 

Infinite recursion and infinite nested simulations demonstrate the exact 
same dynamic behavior pattern.

> I think you are agreeing that there are no recursive calls.  But doesn't
> the trace show that there are?  I thought it did.
> 

Infinite recursion and infinite nested simulations demonstrate the exact 
same (infinite execution) dynamic behavior pattern.

> By the way, I can also to "big picture" stuff.  I don't always nit-pick.
> See, for example, the text at the very top where, by not objecting, you
> are implicitly agreeing by high-level summary of what you doing.
> 
>> I need not show the code of Halts(),
> 
> Well you /should/.  But I accept that you mustn't in order to keep
> stringing people along.  After all, it's the chatting you like.
> 
>> http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf
> 
> That paper clearly says that you are talking about recursive calls.  In
> other words, that paper uses the language correctly, and I assume the
> trace shows recursive calls as well.  This suggests that either the
> trace is fake or Halts is not at all as you described it last year.  Or
> maybe the paper uses the wrong words.  Something is screwey.
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#32603 — 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-02 20:49 -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<8MHjI.345907$nn2.134064@fx48.iad>
In reply to#32600
On 5/2/21 8:34 PM, olcott wrote:

> Since the halt deciding criteria that matches infinite recursion is
> exactly the same as the criteria that matches infinite nested
> simulations and infinite nested simulations are computationally
> equivalent to infinite recursion I can them both infinite recursion.

You mean the same criteria that applies to ANY computation, does the
Computation actually halt or not? (And H_Hat halts).
> 
> The halt decider knows nothing about infinitely nested simulations it
> only knows that its infinite recursion dynamic behavior pattern has been
> matched.

It should. It obviously isn't simulating the simulator. This also point
out the error in building the machine of NOT making a copy of Halts when
H_Hat was built.

As I mentioned elsewhere, my guess is that Halts isn't actually a real
computation in implementation, thus showing that it isn't really a
Turing Machine Equivalent on its own, thus can't qualify as a true Halt
Decider.

[toc] | [prev] | [next] | [standalone]


Page 2 of 5 — ← Prev page 1 [2] 3 4 5  Next page →

Back to top | Article view | comp.theory


csiph-web