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


Groups > comp.theory > #39791 > unrolled thread

Is it possible to create a simple infinite emulation detector?

Started byolcott <NoOne@NoWhere.com>
First post2021-09-23 13:30 -0500
Last post2021-09-26 06:39 -0400
Articles 20 on this page of 64 — 6 participants

Back to article view | Back to comp.theory


Contents

  Is it possible to create a simple infinite emulation detector? olcott <NoOne@NoWhere.com> - 2021-09-23 13:30 -0500
    Re: Is it possible to create a simple infinite emulation detector? André G. Isaak <agisaak@gm.invalid> - 2021-09-23 19:17 -0600
      Re: Is it possible to create a simple infinite emulation detector? olcott <NoOne@NoWhere.com> - 2021-09-23 20:25 -0500
        Re: Is it possible to create a simple infinite emulation detector? André G. Isaak <agisaak@gm.invalid> - 2021-09-23 19:58 -0600
          Re: Is it possible to create a simple infinite emulation detector? olcott <NoOne@NoWhere.com> - 2021-09-23 22:13 -0500
            Re: Is it possible to create a simple infinite emulation detector? Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:25 -0400
            Re: Is it possible to create a simple infinite emulation detector? André G. Isaak <agisaak@gm.invalid> - 2021-09-23 21:38 -0600
        Re: Is it possible to create a simple infinite emulation detector? Richard Damon <Richard@Damon-Family.org> - 2021-09-23 22:14 -0400
    Re: Is it possible to create a simple infinite emulation detector? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-24 02:42 +0100
      Re: Is it possible to create a simple infinite emulation detector? olcott <NoOne@NoWhere.com> - 2021-09-23 21:01 -0500
        Re: Is it possible to create a simple infinite emulation detector? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-24 03:03 +0100
    Re: Is it possible to create a simple infinite emulation detector? Richard Damon <Richard@Damon-Family.org> - 2021-09-23 22:09 -0400
      Re: Is it possible to create a simple infinite emulation detector? olcott <NoOne@NoWhere.com> - 2021-09-23 22:27 -0500
        Re: Is it possible to create a simple infinite emulation detector? Richard Damon <Richard@Damon-Family.org> - 2021-09-23 23:39 -0400
          Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-24 09:49 -0500
            Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-24 21:54 +0100
              Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-24 16:53 -0500
                Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 00:22 +0100
                  Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-24 19:01 -0500
                    Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 21:43 +0100
                      Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 15:47 -0500
                        Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 22:24 +0100
                          Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 17:51 -0500
                            Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-26 00:55 +0100
                              Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 22:00 -0500
                                Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-26 06:26 -0400
                                Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-26 15:30 +0100
            Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 20:09 -0400
              Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-24 19:48 -0500
                Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 21:27 -0400
                  Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-24 20:52 -0500
                    Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-24 22:27 -0400
                      Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-24 22:36 -0500
                        Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-24 23:31 -0500
                          Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 06:06 -0400
                            Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 09:09 -0500
                              Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 12:09 -0400
                                Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 11:18 -0500
                                  Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 12:24 -0400
                        Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 06:03 -0400
                          Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 08:58 -0500
                            Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 10:07 -0400
                              Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 09:18 -0500
                                Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 12:14 -0400
                        Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Mr Flibble <flibble@reddwarf.jmc> - 2021-09-25 18:54 +0100
                          Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Jeff Barnett <jbb@notatt.com> - 2021-09-25 12:17 -0600
                          Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 14:02 -0500
                Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 20:54 +0100
                  Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 15:07 -0500
                    Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 22:15 +0100
                      Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 16:30 -0500
                  Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 17:30 -0400
                    Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-25 22:54 +0100
                      Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 18:14 -0400
                        Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 22:13 -0500
                          Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-26 14:57 +0100
                      Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 17:59 -0500
                        Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-26 00:33 +0100
                          Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 21:45 -0500
                            Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-26 06:32 -0400
                            Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-26 15:20 +0100
                        Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-25 21:18 -0400
                          Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] olcott <NoOne@NoWhere.com> - 2021-09-25 22:03 -0500
                            Re: Is it possible to create a simple infinite emulation detector? [ cite sources ] Richard Damon <Richard@Damon-Family.org> - 2021-09-26 06:39 -0400

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


#39892 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 08:58 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<84WdnSAskLlst9L8nZ2dnUU7-c_NnZ2d@giganews.com>
In reply to#39888
On 9/25/2021 5:03 AM, Richard Damon wrote:
> On 9/24/21 11:36 PM, olcott wrote:
>> On 9/24/2021 9:27 PM, Richard Damon wrote:
>>> On 9/24/21 9:52 PM, olcott wrote:
>>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>>
>>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>>> {
>>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>         printf("H is called in infinitely nested emulation =
>>>>>>>>>>>> ", H(P,
>>>>>>>>>>>> P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug step
>>>>>>>>>>>> mode.
>>>>>>>>>>>>
>>>>>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>>>>>> giving
>>>>>>>>>>>> them an opportunity to either correct my errors or failing that
>>>>>>>>>>>> show
>>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>>> analyze the
>>>>>>>>>>>> problem as presented.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is quite possible in the realm of H to detect that it has been
>>>>>>>>>>> called
>>>>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked
>>>>>>>>>>> within
>>>>>>>>>>> another instance of H with the same parameters. You code does
>>>>>>>>>>> this
>>>>>>>>>>> successfully.
>>>>>>>>>>>
>>>>>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>>>>>> decided
>>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>>> detecting
>>>>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>>>>> 'copy' of
>>>>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>>>>> Linz, as
>>>>>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>>>>>> limited
>>>>>>>>>>> model.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>>> essence of
>>>>>>>>>> the liar paradox pattern.
>>>>>>>>>
>>>>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>>>>>> requires H to be a real computation, and H^ built sufficiently like
>>>>>>>>> Linz
>>>>>>>>> does.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>>> what is
>>>>>>>> and what is not an actual computation. The term of the art for
>>>>>>>> this is
>>>>>>>> "computable function", therefore if you are not a liar or
>>>>>>>> incompetent
>>>>>>>> you would be able to cite sources that conform your assessments.
>>>>>>>
>>>>>>> There is a difference between a Computable Function and a
>>>>>>> Computation,
>>>>>>> but it might be too subtle for you.
>>>>>>>
>>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>>> computable, i.e. there exists an algorithm that is able to generate
>>>>>>> that
>>>>>>> mapping.
>>>>>>>
>>>>>>
>>>>>> I derive a unique mapping from an input finite string to a Boolean
>>>>>> value. I currently need static local data to do this, none-the-less a
>>>>>> unique mapping is derived. I can't understand how this is
>>>>>> computable in
>>>>>> C and not computable in a TM.
>>>>>>
>>>>>
>>>>> The problem is that to be a Computatable Function ALL refereces to that
>>>>> Function need to generate that same mapping.
>>>>>
>>>>> That means that the P that call this 'Computable Function' H must get
>>>>> the exact same answer as H give when just asked.
>>>>
>>>> So we are back to a function called in infinite recursion must return to
>>>> its caller even though everyone know this is impossible.
>>>
>>> Except that it ISN'T infinite recursion, since EVERY H will abort its
>>> simulation and return after finite time.
>>>
>>> Do you not understand that fact?
>>>
>>
>> If the question was:
>> Does P on its input stop running?
>> Then H provides the wrong answer.
>>
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>>
>> I have told you this many hundreds of times so I estimate that you may
>> have an actual neurological disorder.
>>
> 
> But it IS the question that the Halt Decider is SUPPOSED to be answering.
> 
> If you have decided you need to answer some different question, fine,
> you just aren't working on the Halting Problem.
> 
> PERIOD. DEFINITION.
> 

Whether or not the input P ever reaches its final state is an equivalent 
question.

> You don't get to make up your own rules if you want to play the real game.
> 
> 
> I guess this is your admission that you have NEVER been talking about
> the actual halting problem  but just about POOP.
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39894 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-25 10:07 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<O2G3J.17527$2e3.10042@fx29.iad>
In reply to#39892
On 9/25/21 9:58 AM, olcott wrote:
> On 9/25/2021 5:03 AM, Richard Damon wrote:
>> On 9/24/21 11:36 PM, olcott wrote:
>>> On 9/24/2021 9:27 PM, Richard Damon wrote:
>>>> On 9/24/21 9:52 PM, olcott wrote:
>>>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>>>
>>>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>         printf("H is called in infinitely nested emulation =
>>>>>>>>>>>>> ", H(P,
>>>>>>>>>>>>> P));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug step
>>>>>>>>>>>>> mode.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>>>>>>> giving
>>>>>>>>>>>>> them an opportunity to either correct my errors or failing
>>>>>>>>>>>>> that
>>>>>>>>>>>>> show
>>>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>>>> analyze the
>>>>>>>>>>>>> problem as presented.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It is quite possible in the realm of H to detect that it has
>>>>>>>>>>>> been
>>>>>>>>>>>> called
>>>>>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked
>>>>>>>>>>>> within
>>>>>>>>>>>> another instance of H with the same parameters. You code does
>>>>>>>>>>>> this
>>>>>>>>>>>> successfully.
>>>>>>>>>>>>
>>>>>>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>>>>>>> decided
>>>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>>>> detecting
>>>>>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>>>>>> 'copy' of
>>>>>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>>>>>> Linz, as
>>>>>>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>>>>>>> limited
>>>>>>>>>>>> model.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>>>> essence of
>>>>>>>>>>> the liar paradox pattern.
>>>>>>>>>>
>>>>>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>>>>>>> requires H to be a real computation, and H^ built sufficiently
>>>>>>>>>> like
>>>>>>>>>> Linz
>>>>>>>>>> does.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>>>> what is
>>>>>>>>> and what is not an actual computation. The term of the art for
>>>>>>>>> this is
>>>>>>>>> "computable function", therefore if you are not a liar or
>>>>>>>>> incompetent
>>>>>>>>> you would be able to cite sources that conform your assessments.
>>>>>>>>
>>>>>>>> There is a difference between a Computable Function and a
>>>>>>>> Computation,
>>>>>>>> but it might be too subtle for you.
>>>>>>>>
>>>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>>>> computable, i.e. there exists an algorithm that is able to generate
>>>>>>>> that
>>>>>>>> mapping.
>>>>>>>>
>>>>>>>
>>>>>>> I derive a unique mapping from an input finite string to a Boolean
>>>>>>> value. I currently need static local data to do this,
>>>>>>> none-the-less a
>>>>>>> unique mapping is derived. I can't understand how this is
>>>>>>> computable in
>>>>>>> C and not computable in a TM.
>>>>>>>
>>>>>>
>>>>>> The problem is that to be a Computatable Function ALL refereces to
>>>>>> that
>>>>>> Function need to generate that same mapping.
>>>>>>
>>>>>> That means that the P that call this 'Computable Function' H must get
>>>>>> the exact same answer as H give when just asked.
>>>>>
>>>>> So we are back to a function called in infinite recursion must
>>>>> return to
>>>>> its caller even though everyone know this is impossible.
>>>>
>>>> Except that it ISN'T infinite recursion, since EVERY H will abort its
>>>> simulation and return after finite time.
>>>>
>>>> Do you not understand that fact?
>>>>
>>>
>>> If the question was:
>>> Does P on its input stop running?
>>> Then H provides the wrong answer.
>>>
>>> THIS IS NOT THE QUESTION
>>> THIS IS NOT THE QUESTION
>>> THIS IS NOT THE QUESTION
>>> THIS IS NOT THE QUESTION
>>>
>>> I have told you this many hundreds of times so I estimate that you may
>>> have an actual neurological disorder.
>>>
>>
>> But it IS the question that the Halt Decider is SUPPOSED to be answering.
>>
>> If you have decided you need to answer some different question, fine,
>> you just aren't working on the Halting Problem.
>>
>> PERIOD. DEFINITION.
>>
> 
> Whether or not the input P ever reaches its final state is an equivalent
> question.
> 

Again, you speak non-sense.

The 'Input' doesn't ever actually DO anything. It is merely a string of
symbols.

The Actual Machine that this input represets, DO reach its final state.

Do you now want to try to deny that this is what happens?

Remember, you have previously shown traces of this happening.

It is also a natural consequence of the claim that when we run H(P,P) it
gives the non-halting response (assuming that H is the required
computation).


You try to LIE with your non-sense because what you MEAN is that H never
sees in its own PARTIAL simulation that P given <P> reaches a halting
state. But that statement reveals its own fault, so you don't want to
say that.

YOU FAIL.

YOU LIE.

YOU are doomed to be a failure unless you repent and accept what is the
real truth.

>> You don't get to make up your own rules if you want to play the real
>> game.
>>
>>
>> I guess this is your admission that you have NEVER been talking about
>> the actual halting problem  but just about POOP.
>>
> 
> 

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


#39897 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 09:18 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<Kdqdnc4YTY1YstL8nZ2dnUU7-N2dnZ2d@giganews.com>
In reply to#39894
On 9/25/2021 9:07 AM, Richard Damon wrote:
> On 9/25/21 9:58 AM, olcott wrote:
>> On 9/25/2021 5:03 AM, Richard Damon wrote:
>>> On 9/24/21 11:36 PM, olcott wrote:
>>>> On 9/24/2021 9:27 PM, Richard Damon wrote:
>>>>> On 9/24/21 9:52 PM, olcott wrote:
>>>>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>          H(x, x);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>          printf("H is called in infinitely nested emulation =
>>>>>>>>>>>>>> ", H(P,
>>>>>>>>>>>>>> P));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug step
>>>>>>>>>>>>>> mode.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>>>>>>>> giving
>>>>>>>>>>>>>> them an opportunity to either correct my errors or failing
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> show
>>>>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>>>>> analyze the
>>>>>>>>>>>>>> problem as presented.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is quite possible in the realm of H to detect that it has
>>>>>>>>>>>>> been
>>>>>>>>>>>>> called
>>>>>>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked
>>>>>>>>>>>>> within
>>>>>>>>>>>>> another instance of H with the same parameters. You code does
>>>>>>>>>>>>> this
>>>>>>>>>>>>> successfully.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>>>>>>>> decided
>>>>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>>>>> detecting
>>>>>>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>>>>>>> 'copy' of
>>>>>>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>>>>>>> Linz, as
>>>>>>>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>>>>>>>> limited
>>>>>>>>>>>>> model.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>>>>> essence of
>>>>>>>>>>>> the liar paradox pattern.
>>>>>>>>>>>
>>>>>>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>>>>>>>> requires H to be a real computation, and H^ built sufficiently
>>>>>>>>>>> like
>>>>>>>>>>> Linz
>>>>>>>>>>> does.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>>>>> what is
>>>>>>>>>> and what is not an actual computation. The term of the art for
>>>>>>>>>> this is
>>>>>>>>>> "computable function", therefore if you are not a liar or
>>>>>>>>>> incompetent
>>>>>>>>>> you would be able to cite sources that conform your assessments.
>>>>>>>>>
>>>>>>>>> There is a difference between a Computable Function and a
>>>>>>>>> Computation,
>>>>>>>>> but it might be too subtle for you.
>>>>>>>>>
>>>>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>>>>> computable, i.e. there exists an algorithm that is able to generate
>>>>>>>>> that
>>>>>>>>> mapping.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I derive a unique mapping from an input finite string to a Boolean
>>>>>>>> value. I currently need static local data to do this,
>>>>>>>> none-the-less a
>>>>>>>> unique mapping is derived. I can't understand how this is
>>>>>>>> computable in
>>>>>>>> C and not computable in a TM.
>>>>>>>>
>>>>>>>
>>>>>>> The problem is that to be a Computatable Function ALL refereces to
>>>>>>> that
>>>>>>> Function need to generate that same mapping.
>>>>>>>
>>>>>>> That means that the P that call this 'Computable Function' H must get
>>>>>>> the exact same answer as H give when just asked.
>>>>>>
>>>>>> So we are back to a function called in infinite recursion must
>>>>>> return to
>>>>>> its caller even though everyone know this is impossible.
>>>>>
>>>>> Except that it ISN'T infinite recursion, since EVERY H will abort its
>>>>> simulation and return after finite time.
>>>>>
>>>>> Do you not understand that fact?
>>>>>
>>>>
>>>> If the question was:
>>>> Does P on its input stop running?
>>>> Then H provides the wrong answer.
>>>>
>>>> THIS IS NOT THE QUESTION
>>>> THIS IS NOT THE QUESTION
>>>> THIS IS NOT THE QUESTION
>>>> THIS IS NOT THE QUESTION
>>>>
>>>> I have told you this many hundreds of times so I estimate that you may
>>>> have an actual neurological disorder.
>>>>
>>>
>>> But it IS the question that the Halt Decider is SUPPOSED to be answering.
>>>
>>> If you have decided you need to answer some different question, fine,
>>> you just aren't working on the Halting Problem.
>>>
>>> PERIOD. DEFINITION.
>>>
>>
>> Whether or not the input P ever reaches its final state is an equivalent
>> question.
>>
> 
> Again, you speak non-sense.
> 
> The 'Input' doesn't ever actually DO anything. It is merely a string of
> symbols.
> 
> The Actual Machine that this input represets, DO reach its final state.
> 
> Do you now want to try to deny that this is what happens?
> 

When I say that I have a black cat proof that I do not have a white dog 
is the strawman error that I have been calling a dishonest dodge.

_P()
[000017f6](01)  55              push ebp
[000017f7](02)  8bec            mov ebp,esp
[000017f9](03)  8b4508          mov eax,[ebp+08]
[000017fc](01)  50              push eax      // push P
[000017fd](03)  8b4d08          mov ecx,[ebp+08]
[00001800](01)  51              push ecx      // push P
[00001801](05)  e880fdffff      call 00001586 // call H
[00001806](03)  83c408          add esp,+08
[00001809](02)  85c0            test eax,eax
[0000180b](02)  7402            jz 0000180f
[0000180d](02)  ebfe            jmp 0000180d
[0000180f](01)  5d              pop ebp
[00001810](01)  c3              ret
Size in bytes:(0027) [00001810]


void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
}

int main() { H(P,P); }

In the above computation P never gets past its machine address 0x1801
whether or not H aborts its simulation or allows P to execute forever.

int main() { P(P); } // is an entirely different computation


-- 
Copyright 2021 Pete Olcott

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

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


#39899 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-25 12:14 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<LVH3J.203343$T_8.28157@fx48.iad>
In reply to#39897
On 9/25/21 10:18 AM, olcott wrote:
> On 9/25/2021 9:07 AM, Richard Damon wrote:
>> On 9/25/21 9:58 AM, olcott wrote:
>>> On 9/25/2021 5:03 AM, Richard Damon wrote:
>>>> On 9/24/21 11:36 PM, olcott wrote:
>>>>> On 9/24/2021 9:27 PM, Richard Damon wrote:
>>>>>> On 9/24/21 9:52 PM, olcott wrote:
>>>>>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>>>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>          H(x, x);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>          printf("H is called in infinitely nested
>>>>>>>>>>>>>>> emulation =
>>>>>>>>>>>>>>> ", H(P,
>>>>>>>>>>>>>>> P));
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug
>>>>>>>>>>>>>>> step
>>>>>>>>>>>>>>> mode.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since people are telling me that my solution is incorrect
>>>>>>>>>>>>>>> I am
>>>>>>>>>>>>>>> giving
>>>>>>>>>>>>>>> them an opportunity to either correct my errors or failing
>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>> show
>>>>>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>>>>>> analyze the
>>>>>>>>>>>>>>> problem as presented.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is quite possible in the realm of H to detect that it has
>>>>>>>>>>>>>> been
>>>>>>>>>>>>>> called
>>>>>>>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked
>>>>>>>>>>>>>> within
>>>>>>>>>>>>>> another instance of H with the same parameters. You code does
>>>>>>>>>>>>>> this
>>>>>>>>>>>>>> successfully.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since this H is only a limited decider, since the program
>>>>>>>>>>>>>> to be
>>>>>>>>>>>>>> decided
>>>>>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>>>>>> detecting
>>>>>>>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>>>>>>>> 'copy' of
>>>>>>>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>>>>>>>> Linz, as
>>>>>>>>>>>>>> it can't accept ANY input machine, but only those that fit
>>>>>>>>>>>>>> this
>>>>>>>>>>>>>> limited
>>>>>>>>>>>>>> model.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>>>>>> essence of
>>>>>>>>>>>>> the liar paradox pattern.
>>>>>>>>>>>>
>>>>>>>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>>>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that.
>>>>>>>>>>>> This
>>>>>>>>>>>> requires H to be a real computation, and H^ built sufficiently
>>>>>>>>>>>> like
>>>>>>>>>>>> Linz
>>>>>>>>>>>> does.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>>>>>> what is
>>>>>>>>>>> and what is not an actual computation. The term of the art for
>>>>>>>>>>> this is
>>>>>>>>>>> "computable function", therefore if you are not a liar or
>>>>>>>>>>> incompetent
>>>>>>>>>>> you would be able to cite sources that conform your assessments.
>>>>>>>>>>
>>>>>>>>>> There is a difference between a Computable Function and a
>>>>>>>>>> Computation,
>>>>>>>>>> but it might be too subtle for you.
>>>>>>>>>>
>>>>>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>>>>>> computable, i.e. there exists an algorithm that is able to
>>>>>>>>>> generate
>>>>>>>>>> that
>>>>>>>>>> mapping.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I derive a unique mapping from an input finite string to a Boolean
>>>>>>>>> value. I currently need static local data to do this,
>>>>>>>>> none-the-less a
>>>>>>>>> unique mapping is derived. I can't understand how this is
>>>>>>>>> computable in
>>>>>>>>> C and not computable in a TM.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The problem is that to be a Computatable Function ALL refereces to
>>>>>>>> that
>>>>>>>> Function need to generate that same mapping.
>>>>>>>>
>>>>>>>> That means that the P that call this 'Computable Function' H
>>>>>>>> must get
>>>>>>>> the exact same answer as H give when just asked.
>>>>>>>
>>>>>>> So we are back to a function called in infinite recursion must
>>>>>>> return to
>>>>>>> its caller even though everyone know this is impossible.
>>>>>>
>>>>>> Except that it ISN'T infinite recursion, since EVERY H will abort its
>>>>>> simulation and return after finite time.
>>>>>>
>>>>>> Do you not understand that fact?
>>>>>>
>>>>>
>>>>> If the question was:
>>>>> Does P on its input stop running?
>>>>> Then H provides the wrong answer.
>>>>>
>>>>> THIS IS NOT THE QUESTION
>>>>> THIS IS NOT THE QUESTION
>>>>> THIS IS NOT THE QUESTION
>>>>> THIS IS NOT THE QUESTION
>>>>>
>>>>> I have told you this many hundreds of times so I estimate that you may
>>>>> have an actual neurological disorder.
>>>>>
>>>>
>>>> But it IS the question that the Halt Decider is SUPPOSED to be
>>>> answering.
>>>>
>>>> If you have decided you need to answer some different question, fine,
>>>> you just aren't working on the Halting Problem.
>>>>
>>>> PERIOD. DEFINITION.
>>>>
>>>
>>> Whether or not the input P ever reaches its final state is an equivalent
>>> question.
>>>
>>
>> Again, you speak non-sense.
>>
>> The 'Input' doesn't ever actually DO anything. It is merely a string of
>> symbols.
>>
>> The Actual Machine that this input represets, DO reach its final state.
>>
>> Do you now want to try to deny that this is what happens?
>>
> 
> When I say that I have a black cat proof that I do not have a white dog
> is the strawman error that I have been calling a dishonest dodge.

No, when
> 
> _P()
> [000017f6](01)  55              push ebp
> [000017f7](02)  8bec            mov ebp,esp
> [000017f9](03)  8b4508          mov eax,[ebp+08]
> [000017fc](01)  50              push eax      // push P
> [000017fd](03)  8b4d08          mov ecx,[ebp+08]
> [00001800](01)  51              push ecx      // push P
> [00001801](05)  e880fdffff      call 00001586 // call H
> [00001806](03)  83c408          add esp,+08
> [00001809](02)  85c0            test eax,eax
> [0000180b](02)  7402            jz 0000180f
> [0000180d](02)  ebfe            jmp 0000180d
> [0000180f](01)  5d              pop ebp
> [00001810](01)  c3              ret
> Size in bytes:(0027) [00001810]
> 
> 
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
> 
> int main() { H(P,P); }
> 
> In the above computation P never gets past its machine address 0x1801
> whether or not H aborts its simulation or allows P to execute forever.
> 
> int main() { P(P); } // is an entirely different computation
> 
> 

But that isn't the question being asked.

The Question that H is supposed to answer is what does:

int main() {
   P(P);
}

Do, Halt or not/

H is a decider. The program it is supposed to decide is the above
program, that is what 'the input' represents.

You LIE when you say that isn't the question being asked,

Maybe your falsehood is due to stupidity, but it is hard to imagine that
you are really that stupid.


Read what Linz is actually asking about.

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


#39904 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromMr Flibble <flibble@reddwarf.jmc>
Date2021-09-25 18:54 +0100
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<20210925185423.0000610a@reddwarf.jmc>
In reply to#39883
On Fri, 24 Sep 2021 22:36:33 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 9/24/2021 9:27 PM, Richard Damon wrote:
> > On 9/24/21 9:52 PM, olcott wrote:  
> >> On 9/24/2021 8:27 PM, Richard Damon wrote:  
> >>> On 9/24/21 8:48 PM, olcott wrote:  
> >>>> On 9/24/2021 7:09 PM, Richard Damon wrote:  
> >>>>> On 9/24/21 10:49 AM, olcott wrote:  
> >>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:  
> >>>>>>>
> >>>>>>> On 9/23/21 11:27 PM, olcott wrote:  
> >>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:  
> >>>>>>>>>
> >>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:  
> >>>>>>>>>> #include <stdint.h>
> >>>>>>>>>> #define ptr uintptr_t
> >>>>>>>>>>
> >>>>>>>>>> int H(ptr p, ptr i)
> >>>>>>>>>> {
> >>>>>>>>>> // Determine infinitely nested x86 emulation
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> void P(ptr x)
> >>>>>>>>>> {
> >>>>>>>>>>        H(x, x);
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>>        printf("H is called in infinitely nested emulation
> >>>>>>>>>> = ", H(P, P));
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> H would use an x86 emulator to emulate its input in debug
> >>>>>>>>>> step mode.
> >>>>>>>>>>
> >>>>>>>>>> Since people are telling me that my solution is incorrect
> >>>>>>>>>> I am giving
> >>>>>>>>>> them an opportunity to either correct my errors or failing
> >>>>>>>>>> that show
> >>>>>>>>>> that their software engineering skills are insufficient to
> >>>>>>>>>> analyze the
> >>>>>>>>>> problem as presented.
> >>>>>>>>>>
> >>>>>>>>>>  
> >>>>>>>>>
> >>>>>>>>> It is quite possible in the realm of H to detect that it
> >>>>>>>>> has been called
> >>>>>>>>> in 'recursion', i.e. that one instance of H has been
> >>>>>>>>> invoked within another instance of H with the same
> >>>>>>>>> parameters. You code does this successfully.
> >>>>>>>>>
> >>>>>>>>> Since this H is only a limited decider, since the program
> >>>>>>>>> to be decided
> >>>>>>>>> is FORCED to be in the same address space as H, the trick of
> >>>>>>>>> detecting
> >>>>>>>>> the address of H in the simulated machine, and that must be
> >>>>>>>>> a 'copy' of
> >>>>>>>>> this H. (This also means that H isn't the requried decider
> >>>>>>>>> of Linz, as
> >>>>>>>>> it can't accept ANY input machine, but only those that fit
> >>>>>>>>> this limited
> >>>>>>>>> model.
> >>>>>>>>>  
> >>>>>>>>
> >>>>>>>> It is sufficiently the same thing in that it implements the
> >>>>>>>> essence of
> >>>>>>>> the liar paradox pattern.  
> >>>>>>>
> >>>>>>> I thought you were working on that Halting Problem. It needs
> >>>>>>> to sufficienty recreate the Linz H/H^ pattern and decide
> >>>>>>> that. This requires H to be a real computation, and H^ built
> >>>>>>> sufficiently like Linz
> >>>>>>> does.
> >>>>>>>  
> >>>>>>
> >>>>>> I hypothesize that you are either a liar or incompetent about
> >>>>>> what is and what is not an actual computation. The term of the
> >>>>>> art for this is "computable function", therefore if you are
> >>>>>> not a liar or incompetent you would be able to cite sources
> >>>>>> that conform your assessments.  
> >>>>>
> >>>>> There is a difference between a Computable Function and a
> >>>>> Computation, but it might be too subtle for you.
> >>>>>
> >>>>> A Computible Function is the actual Mapping, that happens to be
> >>>>> computable, i.e. there exists an algorithm that is able to
> >>>>> generate that
> >>>>> mapping.
> >>>>>  
> >>>>
> >>>> I derive a unique mapping from an input finite string to a
> >>>> Boolean value. I currently need static local data to do this,
> >>>> none-the-less a unique mapping is derived. I can't understand
> >>>> how this is computable in C and not computable in a TM.
> >>>>  
> >>>
> >>> The problem is that to be a Computatable Function ALL refereces
> >>> to that Function need to generate that same mapping.
> >>>
> >>> That means that the P that call this 'Computable Function' H must
> >>> get the exact same answer as H give when just asked.  
> >>
> >> So we are back to a function called in infinite recursion must
> >> return to its caller even though everyone know this is impossible.
> >>  
> > 
> > Except that it ISN'T infinite recursion, since EVERY H will abort
> > its simulation and return after finite time.
> > 
> > Do you not understand that fact?
> >   
> 
> If the question was:
> Does P on its input stop running?
> Then H provides the wrong answer.
> 
> THIS IS NOT THE QUESTION
> THIS IS NOT THE QUESTION
> THIS IS NOT THE QUESTION
> THIS IS NOT THE QUESTION
> 
> I have told you this many hundreds of times so I estimate that you
> may have an actual neurological disorder.

What qualifications do you have for diagnosing medical disorders over
Usenet?

/Flibble

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


#39905 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromJeff Barnett <jbb@notatt.com>
Date2021-09-25 12:17 -0600
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<sinp4v$ebk$1@dont-email.me>
In reply to#39904
On 9/25/2021 11:54 AM, Mr Flibble wrote:
> On Fri, 24 Sep 2021 22:36:33 -0500
> olcott <NoOne@NoWhere.com> wrote:
> 
>> On 9/24/2021 9:27 PM, Richard Damon wrote:
>>> On 9/24/21 9:52 PM, olcott wrote:
>>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>>
>>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>>> {
>>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>         printf("H is called in infinitely nested emulation
>>>>>>>>>>>> = ", H(P, P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug
>>>>>>>>>>>> step mode.
>>>>>>>>>>>>
>>>>>>>>>>>> Since people are telling me that my solution is incorrect
>>>>>>>>>>>> I am giving
>>>>>>>>>>>> them an opportunity to either correct my errors or failing
>>>>>>>>>>>> that show
>>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>>> analyze the
>>>>>>>>>>>> problem as presented.
>>>>>>>>>>>>
>>>>>>>>>>>>   
>>>>>>>>>>>
>>>>>>>>>>> It is quite possible in the realm of H to detect that it
>>>>>>>>>>> has been called
>>>>>>>>>>> in 'recursion', i.e. that one instance of H has been
>>>>>>>>>>> invoked within another instance of H with the same
>>>>>>>>>>> parameters. You code does this successfully.
>>>>>>>>>>>
>>>>>>>>>>> Since this H is only a limited decider, since the program
>>>>>>>>>>> to be decided
>>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>>> detecting
>>>>>>>>>>> the address of H in the simulated machine, and that must be
>>>>>>>>>>> a 'copy' of
>>>>>>>>>>> this H. (This also means that H isn't the requried decider
>>>>>>>>>>> of Linz, as
>>>>>>>>>>> it can't accept ANY input machine, but only those that fit
>>>>>>>>>>> this limited
>>>>>>>>>>> model.
>>>>>>>>>>>   
>>>>>>>>>>
>>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>>> essence of
>>>>>>>>>> the liar paradox pattern.
>>>>>>>>>
>>>>>>>>> I thought you were working on that Halting Problem. It needs
>>>>>>>>> to sufficienty recreate the Linz H/H^ pattern and decide
>>>>>>>>> that. This requires H to be a real computation, and H^ built
>>>>>>>>> sufficiently like Linz
>>>>>>>>> does.
>>>>>>>>>   
>>>>>>>>
>>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>>> what is and what is not an actual computation. The term of the
>>>>>>>> art for this is "computable function", therefore if you are
>>>>>>>> not a liar or incompetent you would be able to cite sources
>>>>>>>> that conform your assessments.
>>>>>>>
>>>>>>> There is a difference between a Computable Function and a
>>>>>>> Computation, but it might be too subtle for you.
>>>>>>>
>>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>>> computable, i.e. there exists an algorithm that is able to
>>>>>>> generate that
>>>>>>> mapping.
>>>>>>>   
>>>>>>
>>>>>> I derive a unique mapping from an input finite string to a
>>>>>> Boolean value. I currently need static local data to do this,
>>>>>> none-the-less a unique mapping is derived. I can't understand
>>>>>> how this is computable in C and not computable in a TM.
>>>>>>   
>>>>>
>>>>> The problem is that to be a Computatable Function ALL refereces
>>>>> to that Function need to generate that same mapping.
>>>>>
>>>>> That means that the P that call this 'Computable Function' H must
>>>>> get the exact same answer as H give when just asked.
>>>>
>>>> So we are back to a function called in infinite recursion must
>>>> return to its caller even though everyone know this is impossible.
>>>>   
>>>
>>> Except that it ISN'T infinite recursion, since EVERY H will abort
>>> its simulation and return after finite time.
>>>
>>> Do you not understand that fact?
>>>    
>>
>> If the question was:
>> Does P on its input stop running?
>> Then H provides the wrong answer.
>>
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>>
>> I have told you this many hundreds of times so I estimate that you
>> may have an actual neurological disorder.
> 
> What qualifications do you have for diagnosing medical disorders over
> Usenet?

That's obvious: He was an observant person when his/her mental disorders 
were evaluated and now he thinks he's the expert. Doctor vs Patient 
confusion; Professor vs Student confusion; Interesting vs Pathetic 
confusion; Clever vs Lost confusion.

I hope the above is helpful.
-- 
Jeff Barnett

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


#39906 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 14:02 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<lMednU3lk__979L8nZ2dnUU7-K2dnZ2d@giganews.com>
In reply to#39904
On 9/25/2021 12:54 PM, Mr Flibble wrote:
> On Fri, 24 Sep 2021 22:36:33 -0500
> olcott <NoOne@NoWhere.com> wrote:
> 
>> On 9/24/2021 9:27 PM, Richard Damon wrote:
>>> On 9/24/21 9:52 PM, olcott wrote:
>>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>>
>>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>>> {
>>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>         printf("H is called in infinitely nested emulation
>>>>>>>>>>>> = ", H(P, P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug
>>>>>>>>>>>> step mode.
>>>>>>>>>>>>
>>>>>>>>>>>> Since people are telling me that my solution is incorrect
>>>>>>>>>>>> I am giving
>>>>>>>>>>>> them an opportunity to either correct my errors or failing
>>>>>>>>>>>> that show
>>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>>> analyze the
>>>>>>>>>>>> problem as presented.
>>>>>>>>>>>>
>>>>>>>>>>>>   
>>>>>>>>>>>
>>>>>>>>>>> It is quite possible in the realm of H to detect that it
>>>>>>>>>>> has been called
>>>>>>>>>>> in 'recursion', i.e. that one instance of H has been
>>>>>>>>>>> invoked within another instance of H with the same
>>>>>>>>>>> parameters. You code does this successfully.
>>>>>>>>>>>
>>>>>>>>>>> Since this H is only a limited decider, since the program
>>>>>>>>>>> to be decided
>>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>>> detecting
>>>>>>>>>>> the address of H in the simulated machine, and that must be
>>>>>>>>>>> a 'copy' of
>>>>>>>>>>> this H. (This also means that H isn't the requried decider
>>>>>>>>>>> of Linz, as
>>>>>>>>>>> it can't accept ANY input machine, but only those that fit
>>>>>>>>>>> this limited
>>>>>>>>>>> model.
>>>>>>>>>>>   
>>>>>>>>>>
>>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>>> essence of
>>>>>>>>>> the liar paradox pattern.
>>>>>>>>>
>>>>>>>>> I thought you were working on that Halting Problem. It needs
>>>>>>>>> to sufficienty recreate the Linz H/H^ pattern and decide
>>>>>>>>> that. This requires H to be a real computation, and H^ built
>>>>>>>>> sufficiently like Linz
>>>>>>>>> does.
>>>>>>>>>   
>>>>>>>>
>>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>>> what is and what is not an actual computation. The term of the
>>>>>>>> art for this is "computable function", therefore if you are
>>>>>>>> not a liar or incompetent you would be able to cite sources
>>>>>>>> that conform your assessments.
>>>>>>>
>>>>>>> There is a difference between a Computable Function and a
>>>>>>> Computation, but it might be too subtle for you.
>>>>>>>
>>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>>> computable, i.e. there exists an algorithm that is able to
>>>>>>> generate that
>>>>>>> mapping.
>>>>>>>   
>>>>>>
>>>>>> I derive a unique mapping from an input finite string to a
>>>>>> Boolean value. I currently need static local data to do this,
>>>>>> none-the-less a unique mapping is derived. I can't understand
>>>>>> how this is computable in C and not computable in a TM.
>>>>>>   
>>>>>
>>>>> The problem is that to be a Computatable Function ALL refereces
>>>>> to that Function need to generate that same mapping.
>>>>>
>>>>> That means that the P that call this 'Computable Function' H must
>>>>> get the exact same answer as H give when just asked.
>>>>
>>>> So we are back to a function called in infinite recursion must
>>>> return to its caller even though everyone know this is impossible.
>>>>   
>>>
>>> Except that it ISN'T infinite recursion, since EVERY H will abort
>>> its simulation and return after finite time.
>>>
>>> Do you not understand that fact?
>>>    
>>
>> If the question was:
>> Does P on its input stop running?
>> Then H provides the wrong answer.
>>
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>>
>> I have told you this many hundreds of times so I estimate that you
>> may have an actual neurological disorder.
> 
> What qualifications do you have for diagnosing medical disorders over
> Usenet?
> 
> /Flibble
> 

(1) This case was my mistake and I apologized.

(2) When you tell an intelligent person a key point
many hundreds of times and they keep forgetting it
something is definitely wrong.

-- 
Copyright 2021 Pete Olcott

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

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


#39907 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-25 20:54 +0100
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<87ee9cwhwe.fsf@bsb.me.uk>
In reply to#39868
olcott <NoOne@NoWhere.com> writes:

> I derive a unique mapping from an input finite string to a Boolean
> value.

But is it a function?  And is it a function from S* to {true, false}
(for some finite alphabet S)?  It might be, but since you only found out
what a function is a few months ago, it's wise to ask.

Your term "unique mapping from an input finite string to a Boolean
value" is what a coder would say.  It's not the same as a mathematician
saying "f: S* -> {true, false}".

> I currently need static local data to do this, none-the-less a 
> unique mapping is derived. I can't understand how this is computable
> in C and not computable in a TM.

  _Bool f(char *s) { return s; }

is a C function that maps finite strings input strings to Boolean
values.  It has no corresponding TM.

-- 
Ben.

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


#39908 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 15:07 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<tcudnULIYvP1HNL8nZ2dnUU7-dnNnZ2d@giganews.com>
In reply to#39907
On 9/25/2021 2:54 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> I derive a unique mapping from an input finite string to a Boolean
>> value.
> 
> But is it a function?  And is it a function from S* to {true, false}
> (for some finite alphabet S)?  It might be, but since you only found out
> what a function is a few months ago, it's wise to ask.
> 
> Your term "unique mapping from an input finite string to a Boolean
> value" is what a coder would say.  It's not the same as a mathematician
> saying "f: S* -> {true, false}".
> 

"If the procedure is given a k-tuple x in the domain of f, then after a 
finite number of discrete steps the procedure must terminate and produce 
f(x)."

https://en.wikipedia.org/wiki/Computable_function#Characteristics_of_computable_functions

This is typically understood to be a k-tuple x in the domain of f, of 
natural numbers to a natural number.

In other words a mathematical mapping from a finite string to an integer.

>> I currently need static local data to do this, none-the-less a
>> unique mapping is derived. I can't understand how this is computable
>> in C and not computable in a TM.
> 
>    _Bool f(char *s) { return s; }
> 
> is a C function that maps finite strings input strings to Boolean
> values.  It has no corresponding TM.
> 

So you are saying that a k-tuple of ASCII values mapped to one element 
of the set {0, 1} has no corresponding TM ?

-- 
Copyright 2021 Pete Olcott

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

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


#39916 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-25 22:15 +0100
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<87lf3kuzk8.fsf@bsb.me.uk>
In reply to#39908
olcott <NoOne@NoWhere.com> writes:

> On 9/25/2021 2:54 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> I derive a unique mapping from an input finite string to a Boolean
>>> value.
>>
>> But is it a function?  And is it a function from S* to {true, false}
>> (for some finite alphabet S)?  It might be, but since you only found out
>> what a function is a few months ago, it's wise to ask.
>> Your term "unique mapping from an input finite string to a Boolean
>> value" is what a coder would say.  It's not the same as a mathematician
>> saying "f: S* -> {true, false}".
>
> "If the procedure is given a k-tuple x in the domain of f, then after
> a finite number of discrete steps the procedure must terminate and
> produce f(x)."
>
> https://en.wikipedia.org/wiki/Computable_function#Characteristics_of_computable_functions

Thank you, but I know what a computable function is.  I was asking if
you are sure that what you loosely describe as "a unique mapping from an
input finite string to a Boolean value" is indeed a function.

> This is typically understood to be a k-tuple x in the domain of f, of
> natural numbers to a natural number.
>
> In other words a mathematical mapping from a finite string to an
> integer.

No.  "In other words" means using different words to convey the same
meaning.  You've change the meaning with your "other words".

But don't worry about it.  It's all details, and you don't do details.
The key point is that we still don't know if what you have "derived" is
a function or not, because you have not said whether it is or not.

>>> I currently need static local data to do this, none-the-less a
>>> unique mapping is derived. I can't understand how this is computable
>>> in C and not computable in a TM.
>>
>>    _Bool f(char *s) { return s; }
>>
>> is a C function that maps finite strings input strings to Boolean
>> values.  It has no corresponding TM. 
>
> So you are saying that a k-tuple of ASCII values mapped to one element
> of the set {0, 1} has no corresponding TM ?

No.  I wonder what is confusing you?  I tried to give a simple example
to show that your woolly words are not enough, and to help you see that
you should not be baffled by a claim that you might have some C code
that "computes" something that is not TM-computable.

To be fair, I don't think you are pulling any such tricks.  If you were,
surely you would have arranged for your partial decider to give the
right answer, rather than the wrong one?  A partial halt decider being
wrong about it's confounding problem instance does not require any
trickery at all.

-- 
Ben.

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


#39918 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 16:30 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<1ImdnYB6YpVACdL8nZ2dnUU7-VPNnZ2d@giganews.com>
In reply to#39916
On 9/25/2021 4:15 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/25/2021 2:54 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> I derive a unique mapping from an input finite string to a Boolean
>>>> value.
>>>
>>> But is it a function?  And is it a function from S* to {true, false}
>>> (for some finite alphabet S)?  It might be, but since you only found out
>>> what a function is a few months ago, it's wise to ask.
>>> Your term "unique mapping from an input finite string to a Boolean
>>> value" is what a coder would say.  It's not the same as a mathematician
>>> saying "f: S* -> {true, false}".
>>
>> "If the procedure is given a k-tuple x in the domain of f, then after
>> a finite number of discrete steps the procedure must terminate and
>> produce f(x)."
>>
>> https://en.wikipedia.org/wiki/Computable_function#Characteristics_of_computable_functions
> 
> Thank you, but I know what a computable function is.  I was asking if
> you are sure that what you loosely describe as "a unique mapping from an
> input finite string to a Boolean value" is indeed a function.
> 
>> This is typically understood to be a k-tuple x in the domain of f, of
>> natural numbers to a natural number.
>>
>> In other words a mathematical mapping from a finite string to an
>> integer.
> 
> No.  "In other words" means using different words to convey the same
> meaning.  You've change the meaning with your "other words".
> 
> But don't worry about it.  It's all details, and you don't do details.
> The key point is that we still don't know if what you have "derived" is
> a function or not, because you have not said whether it is or not.
> 
>>>> I currently need static local data to do this, none-the-less a
>>>> unique mapping is derived. I can't understand how this is computable
>>>> in C and not computable in a TM.
>>>
>>>     _Bool f(char *s) { return s; }
>>>
>>> is a C function that maps finite strings input strings to Boolean
>>> values.  It has no corresponding TM.
>>
>> So you are saying that a k-tuple of ASCII values mapped to one element
>> of the set {0, 1} has no corresponding TM ?
> 
> No.  I wonder what is confusing you?  

I thought that was a function declaration.
I did not notice the body.

> I tried to give a simple example
> to show that your woolly words are not enough, and to help you see that
> you should not be baffled by a claim that you might have some C code
> that "computes" something that is not TM-computable.
> 
> To be fair, I don't think you are pulling any such tricks.  If you were,
> surely you would have arranged for your partial decider to give the
> right answer, rather than the wrong one?  A partial halt decider being
> wrong about it's confounding problem instance does not require any
> trickery at all.
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39919 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-25 17:30 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<SxM3J.23727$nh7.4164@fx22.iad>
In reply to#39907
On 9/25/21 3:54 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> I derive a unique mapping from an input finite string to a Boolean
>> value.
> 
> But is it a function?  And is it a function from S* to {true, false}
> (for some finite alphabet S)?  It might be, but since you only found out
> what a function is a few months ago, it's wise to ask.
> 
> Your term "unique mapping from an input finite string to a Boolean
> value" is what a coder would say.  It's not the same as a mathematician
> saying "f: S* -> {true, false}".
> 
>> I currently need static local data to do this, none-the-less a 
>> unique mapping is derived. I can't understand how this is computable
>> in C and not computable in a TM.
> 
>   _Bool f(char *s) { return s; }
> 
> is a C function that maps finite strings input strings to Boolean
> values.  It has no corresponding TM.
> 

Actually, you should be able to map that. The key is you need to define
how you encode character strings.

If the tape allows 257 values per cell, corresponding to 'no value' or
the ascii values 0-255, then the test is just is the cell we start at
the 'no value', which is the equivalent for a null pointer, and return
false/0 if it is, else return true.

There is almost ALWAYS a 'mapping' issue of how do you plan to represent
the various representations in one space to another.

One key is that as a whole computation, that is likely not all that
useful. and as a piece of a bigger program, you may well be rearranging
things from how the C code is organized as implementing things just like
C is very inefficient for a Turing Machine.

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


#39920 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-25 22:54 +0100
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<878rzkuxrk.fsf@bsb.me.uk>
In reply to#39919
Richard Damon <Richard@Damon-Family.org> writes:

> On 9/25/21 3:54 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> I derive a unique mapping from an input finite string to a Boolean
>>> value.
>> 
>> But is it a function?  And is it a function from S* to {true, false}
>> (for some finite alphabet S)?  It might be, but since you only found out
>> what a function is a few months ago, it's wise to ask.
>> 
>> Your term "unique mapping from an input finite string to a Boolean
>> value" is what a coder would say.  It's not the same as a mathematician
>> saying "f: S* -> {true, false}".
>> 
>>> I currently need static local data to do this, none-the-less a 
>>> unique mapping is derived. I can't understand how this is computable
>>> in C and not computable in a TM.
>> 
>>   _Bool f(char *s) { return s; }
>> 
>> is a C function that maps finite strings input strings to Boolean
>> values.  It has no corresponding TM.
>
> Actually, you should be able to map that. The key is you need to define
> how you encode character strings.
>
> If the tape allows 257 values per cell, corresponding to 'no value' or
> the ascii values 0-255, then the test is just is the cell we start at
> the 'no value', which is the equivalent for a null pointer, and return
> false/0 if it is, else return true.

OK, not the best example since you might consider that a natural
correspondence.  I'd suggest, then,

  _Bool f(char *s) { return (uintptr_t)s & 1; }

or

  _Bool f(char *s) { return ((uintptr_t)s + (uintptr_t)f) & 0x8800; }

or

  _Bool f(char *s) { return s && *s ? f(s+1) : (uintptr_t)&s & 1; }

> There is almost ALWAYS a 'mapping' issue of how do you plan to represent
> the various representations in one space to another.

Maybe.  I think we may disagree about what a "corresponding TM" really
is.  But that's not the main point I was trying to make: PO's words were
just too vague to address why he's puzzled that something "computable"
in C is not "computable" by a TM.

I agree that we can often define away the issue by being more specific.
The result is then a well-defined function that is can be implemented in
both C and realised as a TM, but lots of C code has no natural
corresponding TM (as I see it).

Also, I just wanted to reiterate why C is such a terrible choice, and
x86 code (RDRAND, anyone?) is even worse, as a formal model of
computation.

-- 
Ben.

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


#39923 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-25 18:14 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<UaN3J.46217$md6.16087@fx36.iad>
In reply to#39920
On 9/25/21 5:54 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> On 9/25/21 3:54 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> I derive a unique mapping from an input finite string to a Boolean
>>>> value.
>>>
>>> But is it a function?  And is it a function from S* to {true, false}
>>> (for some finite alphabet S)?  It might be, but since you only found out
>>> what a function is a few months ago, it's wise to ask.
>>>
>>> Your term "unique mapping from an input finite string to a Boolean
>>> value" is what a coder would say.  It's not the same as a mathematician
>>> saying "f: S* -> {true, false}".
>>>
>>>> I currently need static local data to do this, none-the-less a 
>>>> unique mapping is derived. I can't understand how this is computable
>>>> in C and not computable in a TM.
>>>
>>>   _Bool f(char *s) { return s; }
>>>
>>> is a C function that maps finite strings input strings to Boolean
>>> values.  It has no corresponding TM.
>>
>> Actually, you should be able to map that. The key is you need to define
>> how you encode character strings.
>>
>> If the tape allows 257 values per cell, corresponding to 'no value' or
>> the ascii values 0-255, then the test is just is the cell we start at
>> the 'no value', which is the equivalent for a null pointer, and return
>> false/0 if it is, else return true.
> 
> OK, not the best example since you might consider that a natural
> correspondence.  I'd suggest, then,
> 
>   _Bool f(char *s) { return (uintptr_t)s & 1; }
> 
> or
> 
>   _Bool f(char *s) { return ((uintptr_t)s + (uintptr_t)f) & 0x8800; }
> 
> or
> 
>   _Bool f(char *s) { return s && *s ? f(s+1) : (uintptr_t)&s & 1; }
> 
>> There is almost ALWAYS a 'mapping' issue of how do you plan to represent
>> the various representations in one space to another.
> 
> Maybe.  I think we may disagree about what a "corresponding TM" really
> is.  But that's not the main point I was trying to make: PO's words were
> just too vague to address why he's puzzled that something "computable"
> in C is not "computable" by a TM.
> 
> I agree that we can often define away the issue by being more specific.
> The result is then a well-defined function that is can be implemented in
> both C and realised as a TM, but lots of C code has no natural
> corresponding TM (as I see it).
> 
> Also, I just wanted to reiterate why C is such a terrible choice, and
> x86 code (RDRAND, anyone?) is even worse, as a formal model of
> computation.
> 

If your 'specification' of what you are doing is C code, then you are
going to be forced to deal with a TM dealing with very Cish data types.
It might even turn out that the simplest model is to make the TM be a
RASP machine and start from there.

Note to PO, If you need to make a TM do a specific thing, sometimes the
right answer is to make into a RASP machine. But if you need to accept
ALL or ANY TM, you can't just limit yourself to RASP machines. And you
are dealing with FULL RASP machines, not just a 'subroutine' that is
part of a RASP machine.

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


#39932 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 22:13 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<Ktmdne5AmYzAeNL8nZ2dnUU7-RvNnZ2d@giganews.com>
In reply to#39923
On 9/25/2021 5:14 PM, Richard Damon wrote:
> On 9/25/21 5:54 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> On 9/25/21 3:54 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> I derive a unique mapping from an input finite string to a Boolean
>>>>> value.
>>>>
>>>> But is it a function?  And is it a function from S* to {true, false}
>>>> (for some finite alphabet S)?  It might be, but since you only found out
>>>> what a function is a few months ago, it's wise to ask.
>>>>
>>>> Your term "unique mapping from an input finite string to a Boolean
>>>> value" is what a coder would say.  It's not the same as a mathematician
>>>> saying "f: S* -> {true, false}".
>>>>
>>>>> I currently need static local data to do this, none-the-less a
>>>>> unique mapping is derived. I can't understand how this is computable
>>>>> in C and not computable in a TM.
>>>>
>>>>    _Bool f(char *s) { return s; }
>>>>
>>>> is a C function that maps finite strings input strings to Boolean
>>>> values.  It has no corresponding TM.
>>>
>>> Actually, you should be able to map that. The key is you need to define
>>> how you encode character strings.
>>>
>>> If the tape allows 257 values per cell, corresponding to 'no value' or
>>> the ascii values 0-255, then the test is just is the cell we start at
>>> the 'no value', which is the equivalent for a null pointer, and return
>>> false/0 if it is, else return true.
>>
>> OK, not the best example since you might consider that a natural
>> correspondence.  I'd suggest, then,
>>
>>    _Bool f(char *s) { return (uintptr_t)s & 1; }
>>
>> or
>>
>>    _Bool f(char *s) { return ((uintptr_t)s + (uintptr_t)f) & 0x8800; }
>>
>> or
>>
>>    _Bool f(char *s) { return s && *s ? f(s+1) : (uintptr_t)&s & 1; }
>>
>>> There is almost ALWAYS a 'mapping' issue of how do you plan to represent
>>> the various representations in one space to another.
>>
>> Maybe.  I think we may disagree about what a "corresponding TM" really
>> is.  But that's not the main point I was trying to make: PO's words were
>> just too vague to address why he's puzzled that something "computable"
>> in C is not "computable" by a TM.
>>
>> I agree that we can often define away the issue by being more specific.
>> The result is then a well-defined function that is can be implemented in
>> both C and realised as a TM, but lots of C code has no natural
>> corresponding TM (as I see it).
>>
>> Also, I just wanted to reiterate why C is such a terrible choice, and
>> x86 code (RDRAND, anyone?) is even worse, as a formal model of
>> computation.
>>
> 
> If your 'specification' of what you are doing is C code, then you are
> going to be forced to deal with a TM dealing with very Cish data types.
> It might even turn out that the simplest model is to make the TM be a
> RASP machine and start from there.
> 
> Note to PO, If you need to make a TM do a specific thing, sometimes the
> right answer is to make into a RASP machine. But if you need to accept
> ALL or ANY TM, you can't just limit yourself to RASP machines. And you
> are dealing with FULL RASP machines, not just a 'subroutine' that is
> part of a RASP machine.
> 

Now that I am deriving my alternative halt deciding algorithm it is 
coming into sharp focus exactly how static local data can make C code 
not a pure function of its inputs.

The good news about this newest understanding is that it validates my 
updated algorithm design. It looks like I may be able to exactly 
duplicate the Linz proof as an actual pure function of its inputs.

It it currently looking like I can do this relatively quickly.
The reason that I created the whole x86utm operating system was so that 
major overhauls of my halt decider would be very easy at the C level.

Some of your feedback has been very good. If I made a RASP machine I 
would make an x86 to RASP translator, this way I could still write the 
code in C.

-- 
Copyright 2021 Pete Olcott

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

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


#39936 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-26 14:57 +0100
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<87o88ftp5u.fsf@bsb.me.uk>
In reply to#39932
olcott <NoOne@NoWhere.com> writes:

> Now that I am deriving my alternative halt deciding algorithm it is
> coming into sharp focus exactly how static local data can make C code
> not a pure function of its inputs.

You could have asked pretty much any programmer and they would have
explained it to you.

-- 
Ben.

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


#39925 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 17:59 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<J7ednWrFcad7NNL8nZ2dnUU7-UHNnZ2d@giganews.com>
In reply to#39920
On 9/25/2021 4:54 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> On 9/25/21 3:54 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> I derive a unique mapping from an input finite string to a Boolean
>>>> value.
>>>
>>> But is it a function?  And is it a function from S* to {true, false}
>>> (for some finite alphabet S)?  It might be, but since you only found out
>>> what a function is a few months ago, it's wise to ask.
>>>
>>> Your term "unique mapping from an input finite string to a Boolean
>>> value" is what a coder would say.  It's not the same as a mathematician
>>> saying "f: S* -> {true, false}".
>>>
>>>> I currently need static local data to do this, none-the-less a
>>>> unique mapping is derived. I can't understand how this is computable
>>>> in C and not computable in a TM.
>>>
>>>    _Bool f(char *s) { return s; }
>>>
>>> is a C function that maps finite strings input strings to Boolean
>>> values.  It has no corresponding TM.
>>
>> Actually, you should be able to map that. The key is you need to define
>> how you encode character strings.
>>
>> If the tape allows 257 values per cell, corresponding to 'no value' or
>> the ascii values 0-255, then the test is just is the cell we start at
>> the 'no value', which is the equivalent for a null pointer, and return
>> false/0 if it is, else return true.
> 
> OK, not the best example since you might consider that a natural
> correspondence.  I'd suggest, then,
> 
>    _Bool f(char *s) { return (uintptr_t)s & 1; }
> 
> or
> 
>    _Bool f(char *s) { return ((uintptr_t)s + (uintptr_t)f) & 0x8800; }
> 
> or
> 
>    _Bool f(char *s) { return s && *s ? f(s+1) : (uintptr_t)&s & 1; }
> 
>> There is almost ALWAYS a 'mapping' issue of how do you plan to represent
>> the various representations in one space to another.
> 
> Maybe.  I think we may disagree about what a "corresponding TM" really
> is.  But that's not the main point I was trying to make: PO's words were
> just too vague to address why he's puzzled that something "computable"
> in C is not "computable" by a TM.
> 
> I agree that we can often define away the issue by being more specific.
> The result is then a well-defined function that is can be implemented in
> both C and realised as a TM, but lots of C code has no natural
> corresponding TM (as I see it).
> 
> Also, I just wanted to reiterate why C is such a terrible choice, and
> x86 code (RDRAND, anyone?) is even worse, as a formal model of
> computation.
> 

Yes because everyone knows the carefully studying a hundreds of 
thousands of pages of execution trace is enormously easier than 14 lines 
of execution trace. The 14 lines could take many decades of study before 
understanding how the algorithm is applied whereas 500,000 pages can be 
fully understood in less than a minute.

-- 
Copyright 2021 Pete Olcott

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

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


#39926 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-26 00:33 +0100
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<87zgs0tem2.fsf@bsb.me.uk>
In reply to#39925
olcott <NoOne@NoWhere.com> writes:

> On 9/25/2021 4:54 PM, Ben Bacarisse wrote:

>> Also, I just wanted to reiterate why C is such a terrible choice, and
>> x86 code (RDRAND, anyone?) is even worse, as a formal model of
>> computation.
>
> Yes because everyone knows the carefully studying a hundreds of
> thousands of pages of execution trace is enormously easier than 14
> lines of execution trace. The 14 lines could take many decades of
> study before understanding how the algorithm is applied whereas
> 500,000 pages can be fully understood in less than a minute.

Yet there are many interesting theorems about what can and can not be
computed using simple rigorous models.  If you studied the subject you
would see why no one does this work in C.

Fortunately you are so wrong that no formal model is needed.  In fact we
know you are wrong even though you've kept the code hidden!  You have
(eventually) told us your code gives the wrong answer, and exactly why it
gives the wrong answer.

-- 
Ben.

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


#39929 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 21:45 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<Z5adnScWIL9YQ9L8nZ2dnUU7-efNnZ2d@giganews.com>
In reply to#39926
On 9/25/2021 6:33 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/25/2021 4:54 PM, Ben Bacarisse wrote:
> 
>>> Also, I just wanted to reiterate why C is such a terrible choice, and
>>> x86 code (RDRAND, anyone?) is even worse, as a formal model of
>>> computation.
>>
>> Yes because everyone knows the carefully studying a hundreds of
>> thousands of pages of execution trace is enormously easier than 14
>> lines of execution trace. The 14 lines could take many decades of
>> study before understanding how the algorithm is applied whereas
>> 500,000 pages can be fully understood in less than a minute.
> 
> Yet there are many interesting theorems about what can and can not be
> computed using simple rigorous models.  If you studied the subject you
> would see why no one does this work in C.
> 
> Fortunately you are so wrong that no formal model is needed.  In fact we
> know you are wrong even though you've kept the code hidden!  You have
> (eventually) told us your code gives the wrong answer, and exactly why it
> gives the wrong answer.
> 

Every time that anyone points to any "error" in what I have said it is 
always a dishonest dodge strawman error.

The issue that my C code might not correspond to a TM computation is the 
only issue that remains open.

-- 
Copyright 2021 Pete Olcott

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

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


#39934 — Re: Is it possible to create a simple infinite emulation detector? [ cite sources ]

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-26 06:32 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<R_X3J.132126$lC6.58661@fx41.iad>
In reply to#39929
On 9/25/21 10:45 PM, olcott wrote:
> On 9/25/2021 6:33 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 9/25/2021 4:54 PM, Ben Bacarisse wrote:
>>
>>>> Also, I just wanted to reiterate why C is such a terrible choice, and
>>>> x86 code (RDRAND, anyone?) is even worse, as a formal model of
>>>> computation.
>>>
>>> Yes because everyone knows the carefully studying a hundreds of
>>> thousands of pages of execution trace is enormously easier than 14
>>> lines of execution trace. The 14 lines could take many decades of
>>> study before understanding how the algorithm is applied whereas
>>> 500,000 pages can be fully understood in less than a minute.
>>
>> Yet there are many interesting theorems about what can and can not be
>> computed using simple rigorous models.  If you studied the subject you
>> would see why no one does this work in C.
>>
>> Fortunately you are so wrong that no formal model is needed.  In fact we
>> know you are wrong even though you've kept the code hidden!  You have
>> (eventually) told us your code gives the wrong answer, and exactly why it
>> gives the wrong answer.
>>
> 
> Every time that anyone points to any "error" in what I have said it is
> always a dishonest dodge strawman error.


FALSE. LIAR.

Youc call anything that points out errors to be dishonest dodges.

> 
> The issue that my C code might not correspond to a TM computation is the
> only issue that remains open.
> 

Wrong, but if you do make your Halt Decider an actual computation you
will see things much clearer.

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


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

Back to top | Article view | comp.theory


csiph-web