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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 15:47 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<Pb-dneflRqJ6F9L8nZ2dnUU7-audnZ2d@giganews.com>
In reply to#39913
On 9/25/2021 3:43 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/24/2021 6:22 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/24/2021 3:54 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>> This is wrong since, apparently,
>>>>>      "I always used this symbol Ĥ in the context of the Linz proofs and
>>>>>      never used it in any other way"
>>>>> If Ĥ refers to the Ĥ in Linz's proof your annotations are incorrect, and
>>>>> if Ĥ is being using "in the context of the Linz proof" but denotes
>>>>> something else (what?) then you are not being serious.
>>>>
>>>> As you have indicated that you have recalled I corrected the error in
>>>> the Linz specification that had two start states by changing one of
>>>> these start states to qx.
>>> Not the issue.  (Though I'll note again that you don't use the notation
>>> you came up with in a helpful way.  There is no need for qx because it
>>> could be called H.q0 or, better yet, H.0.)
>>>
>>>> After this I augmented the Linz notation further so that it showed the
>>>> notation when the Linz Ĥ is specifically applied to the Linz ⟨Ĥ⟩ where
>>>> the halt decider embedded at qx is a simulating halt decider.
>>> Not the issue but if you used the . notation better this would be much clearer.
>>>
>>>> Since Linz does not exclude simulating halt deciders this is still the
>>>> Linz Ĥ.
>>>
>>> You annotations are incorrect.  If you'd like to know why, ask an
>>> intelligent question.  But why are you making any claims at all about
>>> TMs that don't exist?
>>
>> How would you annotate all of the steps of the Linz Ĥ applied to its
>> own machine description?
> 
> What new nonsense is this?  No one is annotating "all of the steps" of a
> TM.  The annotations explain which formal statements apply in which
> situations:
> 
>    Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞      if Ĥ applied to ⟨Ĥ⟩ halts, and
>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn   if Ĥ applied to ⟨Ĥ⟩ does not halt.
> 

You skipped some Linz specified states.

-- 
Copyright 2021 Pete Olcott

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

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


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

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

> On 9/25/2021 3:43 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 9/24/2021 6:22 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/24/2021 3:54 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>> This is wrong since, apparently,
>>>>>>      "I always used this symbol Ĥ in the context of the Linz proofs and
>>>>>>      never used it in any other way"
>>>>>> If Ĥ refers to the Ĥ in Linz's proof your annotations are incorrect, and
>>>>>> if Ĥ is being using "in the context of the Linz proof" but denotes
>>>>>> something else (what?) then you are not being serious.
>>>>>
>>>>> As you have indicated that you have recalled I corrected the error in
>>>>> the Linz specification that had two start states by changing one of
>>>>> these start states to qx.
>>>> Not the issue.  (Though I'll note again that you don't use the notation
>>>> you came up with in a helpful way.  There is no need for qx because it
>>>> could be called H.q0 or, better yet, H.0.)
>>>>
>>>>> After this I augmented the Linz notation further so that it showed the
>>>>> notation when the Linz Ĥ is specifically applied to the Linz ⟨Ĥ⟩ where
>>>>> the halt decider embedded at qx is a simulating halt decider.
>>>> Not the issue but if you used the . notation better this would be much clearer.
>>>>
>>>>> Since Linz does not exclude simulating halt deciders this is still the
>>>>> Linz Ĥ.
>>>>
>>>> You annotations are incorrect.  If you'd like to know why, ask an
>>>> intelligent question.  But why are you making any claims at all about
>>>> TMs that don't exist?
>>>
>>> How would you annotate all of the steps of the Linz Ĥ applied to its
>>> own machine description?
>> What new nonsense is this?  No one is annotating "all of the steps" of a
>> TM.  The annotations explain which formal statements apply in which
>> situations:
>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞      if Ĥ applied to ⟨Ĥ⟩ halts, and
>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn   if Ĥ applied to ⟨Ĥ⟩ does not halt.
>
> You skipped some Linz specified states.

Your annotations are still wrong.  Mine (in fact Linz's) are the correct
ones regardless of whether I (or he) includes the states you are so
obsessed with.

Have another go.  See if you can write the two lines about Ĥ.q0 ⟨Ĥ⟩
correctly with intermediate states you love so much.

If you post the lines with the wrong annotations again, I'll point out
that they are wrong again.  At least you now know they are wrong.

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 17:51 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<OdOdnX3XffppOtL8nZ2dnUU7-cvNnZ2d@giganews.com>
In reply to#39917
On 9/25/2021 4:24 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/25/2021 3:43 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/24/2021 6:22 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 9/24/2021 3:54 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>>> This is wrong since, apparently,
>>>>>>>       "I always used this symbol Ĥ in the context of the Linz proofs and
>>>>>>>       never used it in any other way"
>>>>>>> If Ĥ refers to the Ĥ in Linz's proof your annotations are incorrect, and
>>>>>>> if Ĥ is being using "in the context of the Linz proof" but denotes
>>>>>>> something else (what?) then you are not being serious.
>>>>>>
>>>>>> As you have indicated that you have recalled I corrected the error in
>>>>>> the Linz specification that had two start states by changing one of
>>>>>> these start states to qx.
>>>>> Not the issue.  (Though I'll note again that you don't use the notation
>>>>> you came up with in a helpful way.  There is no need for qx because it
>>>>> could be called H.q0 or, better yet, H.0.)
>>>>>
>>>>>> After this I augmented the Linz notation further so that it showed the
>>>>>> notation when the Linz Ĥ is specifically applied to the Linz ⟨Ĥ⟩ where
>>>>>> the halt decider embedded at qx is a simulating halt decider.
>>>>> Not the issue but if you used the . notation better this would be much clearer.
>>>>>
>>>>>> Since Linz does not exclude simulating halt deciders this is still the
>>>>>> Linz Ĥ.
>>>>>
>>>>> You annotations are incorrect.  If you'd like to know why, ask an
>>>>> intelligent question.  But why are you making any claims at all about
>>>>> TMs that don't exist?
>>>>
>>>> How would you annotate all of the steps of the Linz Ĥ applied to its
>>>> own machine description?
>>> What new nonsense is this?  No one is annotating "all of the steps" of a
>>> TM.  The annotations explain which formal statements apply in which
>>> situations:
>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞      if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn   if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>
>> You skipped some Linz specified states.
> 
> Your annotations are still wrong.  Mine (in fact Linz's) are the correct
> ones regardless of whether I (or he) includes the states you are so
> obsessed with.
> 

As always you can dogmatically assert that I am wrong yet cannot provide 
any evidence of my error because there is in fact no error.

> Have another go.  See if you can write the two lines about Ĥ.q0 ⟨Ĥ⟩
> correctly with intermediate states you love so much.
> 

When the halt decider at Ĥ.qx is a simulating halt decider

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt

> If you post the lines with the wrong annotations again, I'll point out
> that they are wrong again.  At least you now know they are wrong.

You can't point out what is wrong about them because there is nothing 
wrong about them. This may only be a lack of comprehension on your part. 
I can't correct this lack without the details of your reasoning. Failing 
to provide any details of your reasoning will revert to my intentional 
deception hypothesis.


-- 
Copyright 2021 Pete Olcott

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

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


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

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

> On 9/25/2021 4:24 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 9/25/2021 3:43 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/24/2021 6:22 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 9/24/2021 3:54 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>>>> This is wrong since, apparently,
>>>>>>>>       "I always used this symbol Ĥ in the context of the Linz proofs and
>>>>>>>>       never used it in any other way"
>>>>>>>> If Ĥ refers to the Ĥ in Linz's proof your annotations are incorrect, and
>>>>>>>> if Ĥ is being using "in the context of the Linz proof" but denotes
>>>>>>>> something else (what?) then you are not being serious.
>>>>>>>
>>>>>>> As you have indicated that you have recalled I corrected the error in
>>>>>>> the Linz specification that had two start states by changing one of
>>>>>>> these start states to qx.
>>>>>> Not the issue.  (Though I'll note again that you don't use the notation
>>>>>> you came up with in a helpful way.  There is no need for qx because it
>>>>>> could be called H.q0 or, better yet, H.0.)
>>>>>>
>>>>>>> After this I augmented the Linz notation further so that it showed the
>>>>>>> notation when the Linz Ĥ is specifically applied to the Linz ⟨Ĥ⟩ where
>>>>>>> the halt decider embedded at qx is a simulating halt decider.
>>>>>> Not the issue but if you used the . notation better this would be much clearer.
>>>>>>
>>>>>>> Since Linz does not exclude simulating halt deciders this is still the
>>>>>>> Linz Ĥ.
>>>>>>
>>>>>> You annotations are incorrect.  If you'd like to know why, ask an
>>>>>> intelligent question.  But why are you making any claims at all about
>>>>>> TMs that don't exist?
>>>>>
>>>>> How would you annotate all of the steps of the Linz Ĥ applied to its
>>>>> own machine description?
>>>> What new nonsense is this?  No one is annotating "all of the steps" of a
>>>> TM.  The annotations explain which formal statements apply in which
>>>> situations:
>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞      if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn   if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>
>>> You skipped some Linz specified states.
>> Your annotations are still wrong.  Mine (in fact Linz's) are the correct
>> ones regardless of whether I (or he) includes the states you are so
>> obsessed with.
>
> As always you can dogmatically assert that I am wrong yet cannot
> provide any evidence of my error because there is in fact no error.

What would be the point in copying here what Linz says in his book
again?  I have, in fact, gone through the steps from the definition of
the problem to the two lines above but it had no effect.  It's right
there in the book -- the simple steps from definition

  H.q0 w ⊢* H.qy   if H applied to w halts, and
  H.q0 w ⊢* H.qn   if H applied to w does not halt,

through the construction of H' and H^ to the conclusion above.  Do you
think you'd pay attention this time if I went though it all again?  No,
you just want to pretend that there is no "evidence" for what I say.

>> Have another go.  See if you can write the two lines about Ĥ.q0 ⟨Ĥ⟩
>> correctly with intermediate states you love so much.
>
> When the halt decider at Ĥ.qx is a simulating halt decider
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt

Provided the first clause applies "if Ĥ applied to ⟨Ĥ⟩ halts", and the
second one "if Ĥ applied to ⟨Ĥ⟩ does not halt", you can add any old guff
you like.  So just make sure you say something like

  Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
  if if Ĥ applied to ⟨Ĥ⟩ halts
  (and by the way, the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts in this case too),

  Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
  if Ĥ applied to ⟨Ĥ⟩ does not halt
  (and, as it happens, the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt also)

in the future.  You may or may not be right about the extra guff (no one
cares), but at least you won't be hiding the truth that shows why no
such H^ exists.

>> If you post the lines with the wrong annotations again, I'll point out
>> that they are wrong again.  At least you now know they are wrong.
>
> You can't point out what is wrong about them because there is nothing
> wrong about them.

They are missing the annotation that shows that no such H^ can exist.
That's quite a big error when think about it.

> This may only be a lack of comprehension on your part.

No, I suspect it's deceitfulness on your part, by there is an old Usenet
maxim: "never attribute to malice, that which can be explained by
ignorance" so I should not jump to conclusions.  It could be that more
than a decade staring at a few pages in Linz, and dozens of explanations
posted here have simply not cured your ignorance on the topic.

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 22:00 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<44mdnfwUwb_Jf9L8nZ2dnUU7-QXNnZ2d@giganews.com>
In reply to#39927
On 9/25/2021 6:55 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/25/2021 4:24 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/25/2021 3:43 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 9/24/2021 6:22 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 9/24/2021 3:54 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>>>>> This is wrong since, apparently,
>>>>>>>>>        "I always used this symbol Ĥ in the context of the Linz proofs and
>>>>>>>>>        never used it in any other way"
>>>>>>>>> If Ĥ refers to the Ĥ in Linz's proof your annotations are incorrect, and
>>>>>>>>> if Ĥ is being using "in the context of the Linz proof" but denotes
>>>>>>>>> something else (what?) then you are not being serious.
>>>>>>>>
>>>>>>>> As you have indicated that you have recalled I corrected the error in
>>>>>>>> the Linz specification that had two start states by changing one of
>>>>>>>> these start states to qx.
>>>>>>> Not the issue.  (Though I'll note again that you don't use the notation
>>>>>>> you came up with in a helpful way.  There is no need for qx because it
>>>>>>> could be called H.q0 or, better yet, H.0.)
>>>>>>>
>>>>>>>> After this I augmented the Linz notation further so that it showed the
>>>>>>>> notation when the Linz Ĥ is specifically applied to the Linz ⟨Ĥ⟩ where
>>>>>>>> the halt decider embedded at qx is a simulating halt decider.
>>>>>>> Not the issue but if you used the . notation better this would be much clearer.
>>>>>>>
>>>>>>>> Since Linz does not exclude simulating halt deciders this is still the
>>>>>>>> Linz Ĥ.
>>>>>>>
>>>>>>> You annotations are incorrect.  If you'd like to know why, ask an
>>>>>>> intelligent question.  But why are you making any claims at all about
>>>>>>> TMs that don't exist?
>>>>>>
>>>>>> How would you annotate all of the steps of the Linz Ĥ applied to its
>>>>>> own machine description?
>>>>> What new nonsense is this?  No one is annotating "all of the steps" of a
>>>>> TM.  The annotations explain which formal statements apply in which
>>>>> situations:
>>>>>      Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞      if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>      Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn   if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>
>>>> You skipped some Linz specified states.
>>> Your annotations are still wrong.  Mine (in fact Linz's) are the correct
>>> ones regardless of whether I (or he) includes the states you are so
>>> obsessed with.
>>
>> As always you can dogmatically assert that I am wrong yet cannot
>> provide any evidence of my error because there is in fact no error.
> 
> What would be the point in copying here what Linz says in his book
> again?  I have, in fact, gone through the steps from the definition of
> the problem to the two lines above but it had no effect.  It's right
> there in the book -- the simple steps from definition
> 
>    H.q0 w ⊢* H.qy   if H applied to w halts, and
>    H.q0 w ⊢* H.qn   if H applied to w does not halt,
> 
> through the construction of H' and H^ to the conclusion above.  Do you
> think you'd pay attention this time if I went though it all again?  No,
> you just want to pretend that there is no "evidence" for what I say.
> 
>>> Have another go.  See if you can write the two lines about Ĥ.q0 ⟨Ĥ⟩
>>> correctly with intermediate states you love so much.
>>
>> When the halt decider at Ĥ.qx is a simulating halt decider
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
> 
> Provided the first clause applies "if Ĥ applied to ⟨Ĥ⟩ halts", and the
> second one "if Ĥ applied to ⟨Ĥ⟩ does not halt", you can add any old guff
> you like.  So just make sure you say something like
> 

That is not what it says and that is not what Linz says.

The halt decider is only at state Ĥ.qx and is only applied to two copies 
of the TM description of Ĥ it cannot be applied to Ĥ itself, the input 
must be a TM description and not a TM.

When the halt decider at Ĥ is a simulating halt decider then it 
transitions to Ĥ.qn on the basis that the simulation of its first TM 
description ⟨Ĥ⟩ applied to its second TM description ⟨Ĥ⟩ never reaches 
its final state whether or not the simulating halt decider at Ĥ.qx ever 
stops simulating this input.



-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-26 06:26 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<IVX3J.54063$2B4.49374@fx04.iad>
In reply to#39930
On 9/25/21 11:00 PM, olcott wrote:
> On 9/25/2021 6:55 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 9/25/2021 4:24 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/25/2021 3:43 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 9/24/2021 6:22 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 9/24/2021 3:54 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>>>>>> This is wrong since, apparently,
>>>>>>>>>>        "I always used this symbol Ĥ in the context of the Linz
>>>>>>>>>> proofs and
>>>>>>>>>>        never used it in any other way"
>>>>>>>>>> If Ĥ refers to the Ĥ in Linz's proof your annotations are
>>>>>>>>>> incorrect, and
>>>>>>>>>> if Ĥ is being using "in the context of the Linz proof" but
>>>>>>>>>> denotes
>>>>>>>>>> something else (what?) then you are not being serious.
>>>>>>>>>
>>>>>>>>> As you have indicated that you have recalled I corrected the
>>>>>>>>> error in
>>>>>>>>> the Linz specification that had two start states by changing
>>>>>>>>> one of
>>>>>>>>> these start states to qx.
>>>>>>>> Not the issue.  (Though I'll note again that you don't use the
>>>>>>>> notation
>>>>>>>> you came up with in a helpful way.  There is no need for qx
>>>>>>>> because it
>>>>>>>> could be called H.q0 or, better yet, H.0.)
>>>>>>>>
>>>>>>>>> After this I augmented the Linz notation further so that it
>>>>>>>>> showed the
>>>>>>>>> notation when the Linz Ĥ is specifically applied to the Linz
>>>>>>>>> ⟨Ĥ⟩ where
>>>>>>>>> the halt decider embedded at qx is a simulating halt decider.
>>>>>>>> Not the issue but if you used the . notation better this would
>>>>>>>> be much clearer.
>>>>>>>>
>>>>>>>>> Since Linz does not exclude simulating halt deciders this is
>>>>>>>>> still the
>>>>>>>>> Linz Ĥ.
>>>>>>>>
>>>>>>>> You annotations are incorrect.  If you'd like to know why, ask an
>>>>>>>> intelligent question.  But why are you making any claims at all
>>>>>>>> about
>>>>>>>> TMs that don't exist?
>>>>>>>
>>>>>>> How would you annotate all of the steps of the Linz Ĥ applied to its
>>>>>>> own machine description?
>>>>>> What new nonsense is this?  No one is annotating "all of the
>>>>>> steps" of a
>>>>>> TM.  The annotations explain which formal statements apply in which
>>>>>> situations:
>>>>>>      Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞      if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>      Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn   if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>
>>>>> You skipped some Linz specified states.
>>>> Your annotations are still wrong.  Mine (in fact Linz's) are the
>>>> correct
>>>> ones regardless of whether I (or he) includes the states you are so
>>>> obsessed with.
>>>
>>> As always you can dogmatically assert that I am wrong yet cannot
>>> provide any evidence of my error because there is in fact no error.
>>
>> What would be the point in copying here what Linz says in his book
>> again?  I have, in fact, gone through the steps from the definition of
>> the problem to the two lines above but it had no effect.  It's right
>> there in the book -- the simple steps from definition
>>
>>    H.q0 w ⊢* H.qy   if H applied to w halts, and
>>    H.q0 w ⊢* H.qn   if H applied to w does not halt,
>>
>> through the construction of H' and H^ to the conclusion above.  Do you
>> think you'd pay attention this time if I went though it all again?  No,
>> you just want to pretend that there is no "evidence" for what I say.
>>
>>>> Have another go.  See if you can write the two lines about Ĥ.q0 ⟨Ĥ⟩
>>>> correctly with intermediate states you love so much.
>>>
>>> When the halt decider at Ĥ.qx is a simulating halt decider
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>
>> Provided the first clause applies "if Ĥ applied to ⟨Ĥ⟩ halts", and the
>> second one "if Ĥ applied to ⟨Ĥ⟩ does not halt", you can add any old guff
>> you like.  So just make sure you say something like
>>
> 
> That is not what it says and that is not what Linz says.
> 
> The halt decider is only at state Ĥ.qx and is only applied to two copies
> of the TM description of Ĥ it cannot be applied to Ĥ itself, the input
> must be a TM description and not a TM.

The Halt Decider is not ONLY at state H^.qx, it is also a fully
indepenent machine, so is there not only one copy of its instruction
present at H^.qx to H^.qn and H^.qy but there is another copy present in
the machine H.q0 to H.qn and H.qy.

> 
> When the halt decider at Ĥ is a simulating halt decider then it
> transitions to Ĥ.qn on the basis that the simulation of its first TM
> description ⟨Ĥ⟩ applied to its second TM description ⟨Ĥ⟩ never reaches
> its final state whether or not the simulating halt decider at Ĥ.qx ever
> stops simulating this input.
> 
>

IF H^ never gets to the state H^.qn, given it got to H^.qx with the
input tape containing <H^> <H^> then that means that the other copy of H
as an indpendent machine given in;ut <H^> <H^> will ALSO not reach its
H.qn state, and thus has failed to be a decider.

By the definition of construction, both the machines at H^.qx and H.q0
have the exact same instruction sequence (unless we reach the qy state)
and the tape of the two machines is exactly the same, so they will do
the exact same sequence of steps and arrive at the exact same result.

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


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

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

> On 9/25/2021 6:55 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 9/25/2021 4:24 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 9/25/2021 3:43 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 9/24/2021 6:22 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 9/24/2021 3:54 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>>>>>> This is wrong since, apparently,
>>>>>>>>>>        "I always used this symbol Ĥ in the context of the Linz proofs and
>>>>>>>>>>        never used it in any other way"
>>>>>>>>>> If Ĥ refers to the Ĥ in Linz's proof your annotations are incorrect, and
>>>>>>>>>> if Ĥ is being using "in the context of the Linz proof" but denotes
>>>>>>>>>> something else (what?) then you are not being serious.
>>>>>>>>>
>>>>>>>>> As you have indicated that you have recalled I corrected the error in
>>>>>>>>> the Linz specification that had two start states by changing one of
>>>>>>>>> these start states to qx.
>>>>>>>> Not the issue.  (Though I'll note again that you don't use the notation
>>>>>>>> you came up with in a helpful way.  There is no need for qx because it
>>>>>>>> could be called H.q0 or, better yet, H.0.)
>>>>>>>>
>>>>>>>>> After this I augmented the Linz notation further so that it showed the
>>>>>>>>> notation when the Linz Ĥ is specifically applied to the Linz ⟨Ĥ⟩ where
>>>>>>>>> the halt decider embedded at qx is a simulating halt decider.
>>>>>>>> Not the issue but if you used the . notation better this would be much clearer.
>>>>>>>>
>>>>>>>>> Since Linz does not exclude simulating halt deciders this is still the
>>>>>>>>> Linz Ĥ.
>>>>>>>>
>>>>>>>> You annotations are incorrect.  If you'd like to know why, ask an
>>>>>>>> intelligent question.  But why are you making any claims at all about
>>>>>>>> TMs that don't exist?
>>>>>>>
>>>>>>> How would you annotate all of the steps of the Linz Ĥ applied to its
>>>>>>> own machine description?
>>>>>> What new nonsense is this?  No one is annotating "all of the steps" of a
>>>>>> TM.  The annotations explain which formal statements apply in which
>>>>>> situations:
>>>>>>      Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞      if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>      Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn   if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>
>>>>> You skipped some Linz specified states.
>>>> Your annotations are still wrong.  Mine (in fact Linz's) are the correct
>>>> ones regardless of whether I (or he) includes the states you are so
>>>> obsessed with.
>>>
>>> As always you can dogmatically assert that I am wrong yet cannot
>>> provide any evidence of my error because there is in fact no error.
>> What would be the point in copying here what Linz says in his book
>> again?  I have, in fact, gone through the steps from the definition of
>> the problem to the two lines above but it had no effect.  It's right
>> there in the book -- the simple steps from definition
>>    H.q0 w ⊢* H.qy   if H applied to w halts, and
>>    H.q0 w ⊢* H.qn   if H applied to w does not halt,
>> through the construction of H' and H^ to the conclusion above.  Do you
>> think you'd pay attention this time if I went though it all again?  No,
>> you just want to pretend that there is no "evidence" for what I say.
>> 
>>>> Have another go.  See if you can write the two lines about Ĥ.q0 ⟨Ĥ⟩
>>>> correctly with intermediate states you love so much.
>>>
>>> When the halt decider at Ĥ.qx is a simulating halt decider
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>
>> Provided the first clause applies "if Ĥ applied to ⟨Ĥ⟩ halts", and the
>> second one "if Ĥ applied to ⟨Ĥ⟩ does not halt", you can add any old guff
>> you like.  So just make sure you say something like
>
> That is not what it says and that is not what Linz says.

To what does "that" refer?  I used your notation, but I cited Linz
correctly.  Please promise to do so in future.  You must state Linz's
annotation for the behaviour of Ĥ because Ĥ is Linz's Ĥ though feel free
to add your junk text.  We can safely ignore it if you keep the correct
annotations in place.

(I was tempted just to reply "liar" but I think you really don't know
what Linz wrote even after decades of studying two and half pages.)

> The halt decider is only at state Ĥ.qx and is only applied to two
> copies of the TM description of Ĥ it cannot be applied to Ĥ itself,
> the input must be a TM description and not a TM.

Yes, it seems you still don't understand what Linz wrote.  Amazing.  I
can explain why Linz correctly says what he says, but I don't think
you'd be able to follow it.  You don't know how to be a student.

-- 
Ben.

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-24 20:09 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<jNt3J.21983$nh7.14432@fx22.iad>
In reply to#39834
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.

A Computation is the running of such an algorithm on an input.

The Turing Machine is an embodiment of an algorithm.

Add an input tape, and you get a Computaton.

The sum set of all input tapes to their results, is a Computable Function.

> 
>>>
>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>> will
>>>> KNOW that if it is programmed to indicate that the computation is
>>>> recursive, that so will the H that it simulated, and thus the recursion
>>>> here is strictly limited.
>>>>
>>>
>>> H knows that is must abort the simulation of its input because its input
>>> never reaches its final state whether or not it aborts this input.
>>
>> It may 'know' that, but it is wrong. Since H does abort its simulation
>> and answer Non-Halting, the machine represented by the input will reach
>> its Halting State.
>>
>>>
>>>> We can add the tracking of all calls that occur, with their parameters,
>>>> and thus detect if its input uses recursion. We can't tell if the
>>>> recursion is infinite, but we can tell that any recursion that goes
>>>> through H with the same parameters will NOT be infinite.
>>>>
>>>> This unfortunately falls short of being a useful Halt Detector, as a
>>>> simple simulator will not be able to tell what happens after this
>>>> simulated copy of itself will do after it aborts as that abort will
>>>> always be later in the execution of the machine that it is simulating
>>>> than when the simulator will abort it.
>>>>
>>>> The task you want to do is proven to be impossible. Impossible to solve
>>>> problems do exist.
>>>>
>>>> The key here is that the actual Question being asked by the Halting
>>>> Problem DOES have an answer, for any given defined machine H, there IS
>>>> a defined machine H^ that can be built from it, and that machine has a
>>>> definite halting status when run on a representation of itself.
>>>>
>>>> It is just demonstrable that it is impossible to design an H that gives
>>>> the right answer for the H^ built from it. That is NOT a contradiction,
>>>> that just shows that designed problem (which is NOT the Queston of the
>>>> Halting Problem) is impossible. This gives us the answer to the second
>>>> question of the Halting Problem, that it IS actually impossible to make
>>>> a Computation that gives the right answer for EVERY possibe
>>>> Machine/Input combinations, as we show how to build amachine that will
>>>> defeat any given machine.
>>>>
>>>
>>> All of the inputs that were defined with the liar paradox pattern
>>> require three halt deciders H1/Hx/H to detect this Liar Paradox pattern
>>> and toss out the one that loses the three-way vote.
>>>
>>>
>>
>> Nope.
>>
>> FAIL.
>>
>> If you define a decider based on 3 copies of H, and call this lets say
>> H3, then you just need to make the H^ pattern based on H3, call it H3^,
>> and your H3 voting pattern will get this wrong.
>>
>> I think all three will detect the infinite recursion and thus the
>> consesus will be non-halting, at which point it will halt, showing them
>> ALL to be wrong, even the majority vote.
>>
>> Depending on how you do the voting, it might be possible for only 2 of
>> the three to get it wrong, if H3 never checks the third machine if the
>> first two agree.
>>
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
> 
> It has already been empirically validated that although the equivalent
> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior of Ĥ.
> 

Nope. You have unsound logic.

The 'H' that gets the right answer is NOT the same 'H' that H^ was built
on, if it was, it would get the exact same answer.

This basically proves that your whole logic is flawed. Most likely
because your C/x86 things that you claim to map to the Turing Machine
are actually the right sort of Computation, so there actually isn't a
Turing Machine for them to the equivalent of.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 19:48 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<j6KdneWvdK9t7NP8nZ2dnUU7-VnNnZ2d@giganews.com>
In reply to#39865
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.

> A Computation is the running of such an algorithm on an input.
> 
> The Turing Machine is an embodiment of an algorithm.
> 
> Add an input tape, and you get a Computaton.
> 
> The sum set of all input tapes to their results, is a Computable Function.
> 
>>
>>>>
>>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>>> will
>>>>> KNOW that if it is programmed to indicate that the computation is
>>>>> recursive, that so will the H that it simulated, and thus the recursion
>>>>> here is strictly limited.
>>>>>
>>>>
>>>> H knows that is must abort the simulation of its input because its input
>>>> never reaches its final state whether or not it aborts this input.
>>>
>>> It may 'know' that, but it is wrong. Since H does abort its simulation
>>> and answer Non-Halting, the machine represented by the input will reach
>>> its Halting State.
>>>
>>>>
>>>>> We can add the tracking of all calls that occur, with their parameters,
>>>>> and thus detect if its input uses recursion. We can't tell if the
>>>>> recursion is infinite, but we can tell that any recursion that goes
>>>>> through H with the same parameters will NOT be infinite.
>>>>>
>>>>> This unfortunately falls short of being a useful Halt Detector, as a
>>>>> simple simulator will not be able to tell what happens after this
>>>>> simulated copy of itself will do after it aborts as that abort will
>>>>> always be later in the execution of the machine that it is simulating
>>>>> than when the simulator will abort it.
>>>>>
>>>>> The task you want to do is proven to be impossible. Impossible to solve
>>>>> problems do exist.
>>>>>
>>>>> The key here is that the actual Question being asked by the Halting
>>>>> Problem DOES have an answer, for any given defined machine H, there IS
>>>>> a defined machine H^ that can be built from it, and that machine has a
>>>>> definite halting status when run on a representation of itself.
>>>>>
>>>>> It is just demonstrable that it is impossible to design an H that gives
>>>>> the right answer for the H^ built from it. That is NOT a contradiction,
>>>>> that just shows that designed problem (which is NOT the Queston of the
>>>>> Halting Problem) is impossible. This gives us the answer to the second
>>>>> question of the Halting Problem, that it IS actually impossible to make
>>>>> a Computation that gives the right answer for EVERY possibe
>>>>> Machine/Input combinations, as we show how to build amachine that will
>>>>> defeat any given machine.
>>>>>
>>>>
>>>> All of the inputs that were defined with the liar paradox pattern
>>>> require three halt deciders H1/Hx/H to detect this Liar Paradox pattern
>>>> and toss out the one that loses the three-way vote.
>>>>
>>>>
>>>
>>> Nope.
>>>
>>> FAIL.
>>>
>>> If you define a decider based on 3 copies of H, and call this lets say
>>> H3, then you just need to make the H^ pattern based on H3, call it H3^,
>>> and your H3 voting pattern will get this wrong.
>>>
>>> I think all three will detect the infinite recursion and thus the
>>> consesus will be non-halting, at which point it will halt, showing them
>>> ALL to be wrong, even the majority vote.
>>>
>>> Depending on how you do the voting, it might be possible for only 2 of
>>> the three to get it wrong, if H3 never checks the third machine if the
>>> first two agree.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>
>> It has already been empirically validated that although the equivalent
>> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
>> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
>> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior of Ĥ.
>>
> 
> Nope. You have unsound logic.
> 
> The 'H' that gets the right answer is NOT the same 'H' that H^ was built
> on, if it was, it would get the exact same answer.
> 

One machine has an input that calls the same halt decider that is 
evaluating it and the other machine does not this makea them distinctly 
different computations even though their code it the same.

> This basically proves that your whole logic is flawed. Most likely
> because your C/x86 things that you claim to map to the Turing Machine
> are actually the right sort of Computation, so there actually isn't a
> Turing Machine for them to the equivalent of.
> 


-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-24 21:27 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<9Wu3J.81772$z%4.62718@fx37.iad>
In reply to#39868
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.

This actually isn't a problem so far, because H(P,P) is non-Halting and
the H(P,P) also gives non-halting, so that can easily be a Computable
Function.

It just isn't a correct Halt Deciding, since when H(P,P) give P(P) that
non-halting answer, P(P) then halts.

When you then claim that H1 is the SAME Computable Function and its
answer is correct, then you have a problem.

Or, when you claim that H's non halting answer while it might not be
correct for the indpendently run P(P) is correct of the P(P) is is
simulating, then that implies that P is not a computable function, as
two instances of it give diffent answers for the same input, but the
structure of P is such that the only way that P isn't computable is if H
itself isn't. The simulated P(P) can only be non halting if the
simulated H(P,P) doesn't answer non-halting which means that H isn't
actually a Computatable Function.

If you allow H to be wrong, then it could be a Turing Machine, but it
just is wrong.

If you don't allow H to be wrong, then it must not actually a Computable
Function, and thus doesn't map to a Turing Machine.

>> A Computation is the running of such an algorithm on an input.
>>
>> The Turing Machine is an embodiment of an algorithm.
>>
>> Add an input tape, and you get a Computaton.
>>
>> The sum set of all input tapes to their results, is a Computable
>> Function.
>>
>>>
>>>>>
>>>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>>>> will
>>>>>> KNOW that if it is programmed to indicate that the computation is
>>>>>> recursive, that so will the H that it simulated, and thus the
>>>>>> recursion
>>>>>> here is strictly limited.
>>>>>>
>>>>>
>>>>> H knows that is must abort the simulation of its input because its
>>>>> input
>>>>> never reaches its final state whether or not it aborts this input.
>>>>
>>>> It may 'know' that, but it is wrong. Since H does abort its simulation
>>>> and answer Non-Halting, the machine represented by the input will reach
>>>> its Halting State.
>>>>
>>>>>
>>>>>> We can add the tracking of all calls that occur, with their
>>>>>> parameters,
>>>>>> and thus detect if its input uses recursion. We can't tell if the
>>>>>> recursion is infinite, but we can tell that any recursion that goes
>>>>>> through H with the same parameters will NOT be infinite.
>>>>>>
>>>>>> This unfortunately falls short of being a useful Halt Detector, as a
>>>>>> simple simulator will not be able to tell what happens after this
>>>>>> simulated copy of itself will do after it aborts as that abort will
>>>>>> always be later in the execution of the machine that it is simulating
>>>>>> than when the simulator will abort it.
>>>>>>
>>>>>> The task you want to do is proven to be impossible. Impossible to
>>>>>> solve
>>>>>> problems do exist.
>>>>>>
>>>>>> The key here is that the actual Question being asked by the Halting
>>>>>> Problem DOES have an answer, for any given defined machine H,
>>>>>> there IS
>>>>>> a defined machine H^ that can be built from it, and that machine
>>>>>> has a
>>>>>> definite halting status when run on a representation of itself.
>>>>>>
>>>>>> It is just demonstrable that it is impossible to design an H that
>>>>>> gives
>>>>>> the right answer for the H^ built from it. That is NOT a
>>>>>> contradiction,
>>>>>> that just shows that designed problem (which is NOT the Queston of
>>>>>> the
>>>>>> Halting Problem) is impossible. This gives us the answer to the
>>>>>> second
>>>>>> question of the Halting Problem, that it IS actually impossible to
>>>>>> make
>>>>>> a Computation that gives the right answer for EVERY possibe
>>>>>> Machine/Input combinations, as we show how to build amachine that
>>>>>> will
>>>>>> defeat any given machine.
>>>>>>
>>>>>
>>>>> All of the inputs that were defined with the liar paradox pattern
>>>>> require three halt deciders H1/Hx/H to detect this Liar Paradox
>>>>> pattern
>>>>> and toss out the one that loses the three-way vote.
>>>>>
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> FAIL.
>>>>
>>>> If you define a decider based on 3 copies of H, and call this lets say
>>>> H3, then you just need to make the H^ pattern based on H3, call it H3^,
>>>> and your H3 voting pattern will get this wrong.
>>>>
>>>> I think all three will detect the infinite recursion and thus the
>>>> consesus will be non-halting, at which point it will halt, showing them
>>>> ALL to be wrong, even the majority vote.
>>>>
>>>> Depending on how you do the voting, it might be possible for only 2 of
>>>> the three to get it wrong, if H3 never checks the third machine if the
>>>> first two agree.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>
>>> It has already been empirically validated that although the equivalent
>>> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
>>> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
>>> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior
>>> of Ĥ.
>>>
>>
>> Nope. You have unsound logic.
>>
>> The 'H' that gets the right answer is NOT the same 'H' that H^ was built
>> on, if it was, it would get the exact same answer.
>>
> 
> One machine has an input that calls the same halt decider that is
> evaluating it and the other machine does not this makea them distinctly
> different computations even though their code it the same.

If they give different answers, they can't be the same Computable
Function. PERIOD.

IF H/H1 can distinguish that P calls H but not H1, then they are not the
same Computable Function. PERIOD.

You can't claim that they actually have the exact same algorithm, but
give different result from the exact same input.

If they really DO have the same algorithm, then the 'input' described is
NOT the complete list of inputs, and thus they fail to be Computable
Fuinctions of the defined input set.

They are a mapping of I+x => O, not I => O.

> 
>> This basically proves that your whole logic is flawed. Most likely
>> because your C/x86 things that you claim to map to the Turing Machine
>> are actually the right sort of Computation, so there actually isn't a
>> Turing Machine for them to the equivalent of.
>>
> 
> 

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 20:52 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<f4GdnfzuHOF3HdP8nZ2dnUU7-SPNnZ2d@giganews.com>
In reply to#39871
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.

Maybe all black cats are really white dogs?

> This actually isn't a problem so far, because H(P,P) is non-Halting and
> the H(P,P) also gives non-halting, so that can easily be a Computable
> Function.
> 

H(P,P) is only non-halting until at least one element of this otherwise 
infinite chain breaks the chain. It makes sense that the element that is 
not called in infinite recursion would be the one that does this.

> It just isn't a correct Halt Deciding, since when H(P,P) give P(P) that
> non-halting answer, P(P) then halts.
> 

They are very similar looking distinctly different comutations that are 
proven to be different by their different execution trace.

H1(P,P) is a similar computation to P(P).

> When you then claim that H1 is the SAME Computable Function and its
> answer is correct, then you have a problem.
> 

Whenever a halt decider must decide halting on an input that calls this 
same halt decider this is an entirely different computation than when an 
exact copy of this code must decide halting on the exact same input that 
does not call this copied halt decider.

You maintain your false assumptions even when presented with easily 
verified facts to the contrary.

> Or, when you claim that H's non halting answer while it might not be
> correct for the indpendently run P(P) is correct of the P(P) is is
> simulating, then that implies that P is not a computable function, as
> two instances of it give diffent answers for the same input, but the
> structure of P is such that the only way that P isn't computable is if H
> itself isn't. The simulated P(P) can only be non halting if the
> simulated H(P,P) doesn't answer non-halting which means that H isn't
> actually a Computatable Function.
> 
> If you allow H to be wrong, then it could be a Turing Machine, but it
> just is wrong.
> 
> If you don't allow H to be wrong, then it must not actually a Computable
> Function, and thus doesn't map to a Turing Machine.
> 
>>> A Computation is the running of such an algorithm on an input.
>>>
>>> The Turing Machine is an embodiment of an algorithm.
>>>
>>> Add an input tape, and you get a Computaton.
>>>
>>> The sum set of all input tapes to their results, is a Computable
>>> Function.
>>>
>>>>
>>>>>>
>>>>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>>>>> will
>>>>>>> KNOW that if it is programmed to indicate that the computation is
>>>>>>> recursive, that so will the H that it simulated, and thus the
>>>>>>> recursion
>>>>>>> here is strictly limited.
>>>>>>>
>>>>>>
>>>>>> H knows that is must abort the simulation of its input because its
>>>>>> input
>>>>>> never reaches its final state whether or not it aborts this input.
>>>>>
>>>>> It may 'know' that, but it is wrong. Since H does abort its simulation
>>>>> and answer Non-Halting, the machine represented by the input will reach
>>>>> its Halting State.
>>>>>
>>>>>>
>>>>>>> We can add the tracking of all calls that occur, with their
>>>>>>> parameters,
>>>>>>> and thus detect if its input uses recursion. We can't tell if the
>>>>>>> recursion is infinite, but we can tell that any recursion that goes
>>>>>>> through H with the same parameters will NOT be infinite.
>>>>>>>
>>>>>>> This unfortunately falls short of being a useful Halt Detector, as a
>>>>>>> simple simulator will not be able to tell what happens after this
>>>>>>> simulated copy of itself will do after it aborts as that abort will
>>>>>>> always be later in the execution of the machine that it is simulating
>>>>>>> than when the simulator will abort it.
>>>>>>>
>>>>>>> The task you want to do is proven to be impossible. Impossible to
>>>>>>> solve
>>>>>>> problems do exist.
>>>>>>>
>>>>>>> The key here is that the actual Question being asked by the Halting
>>>>>>> Problem DOES have an answer, for any given defined machine H,
>>>>>>> there IS
>>>>>>> a defined machine H^ that can be built from it, and that machine
>>>>>>> has a
>>>>>>> definite halting status when run on a representation of itself.
>>>>>>>
>>>>>>> It is just demonstrable that it is impossible to design an H that
>>>>>>> gives
>>>>>>> the right answer for the H^ built from it. That is NOT a
>>>>>>> contradiction,
>>>>>>> that just shows that designed problem (which is NOT the Queston of
>>>>>>> the
>>>>>>> Halting Problem) is impossible. This gives us the answer to the
>>>>>>> second
>>>>>>> question of the Halting Problem, that it IS actually impossible to
>>>>>>> make
>>>>>>> a Computation that gives the right answer for EVERY possibe
>>>>>>> Machine/Input combinations, as we show how to build amachine that
>>>>>>> will
>>>>>>> defeat any given machine.
>>>>>>>
>>>>>>
>>>>>> All of the inputs that were defined with the liar paradox pattern
>>>>>> require three halt deciders H1/Hx/H to detect this Liar Paradox
>>>>>> pattern
>>>>>> and toss out the one that loses the three-way vote.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> FAIL.
>>>>>
>>>>> If you define a decider based on 3 copies of H, and call this lets say
>>>>> H3, then you just need to make the H^ pattern based on H3, call it H3^,
>>>>> and your H3 voting pattern will get this wrong.
>>>>>
>>>>> I think all three will detect the infinite recursion and thus the
>>>>> consesus will be non-halting, at which point it will halt, showing them
>>>>> ALL to be wrong, even the majority vote.
>>>>>
>>>>> Depending on how you do the voting, it might be possible for only 2 of
>>>>> the three to get it wrong, if H3 never checks the third machine if the
>>>>> first two agree.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> It has already been empirically validated that although the equivalent
>>>> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
>>>> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
>>>> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior
>>>> of Ĥ.
>>>>
>>>
>>> Nope. You have unsound logic.
>>>
>>> The 'H' that gets the right answer is NOT the same 'H' that H^ was built
>>> on, if it was, it would get the exact same answer.
>>>
>>
>> One machine has an input that calls the same halt decider that is
>> evaluating it and the other machine does not this makea them distinctly
>> different computations even though their code it the same.
> 
> If they give different answers, they can't be the same Computable
> Function. PERIOD.
> 
> IF H/H1 can distinguish that P calls H but not H1, then they are not the
> same Computable Function. PERIOD.
> 
> You can't claim that they actually have the exact same algorithm, but
> give different result from the exact same input.
> 

P calls H and P does not call H1 this makes a big difference.

> If they really DO have the same algorithm, then the 'input' described is
> NOT the complete list of inputs, and thus they fail to be Computable
> Fuinctions of the defined input set.
> 
> They are a mapping of I+x => O, not I => O.
> 
>>
>>> This basically proves that your whole logic is flawed. Most likely
>>> because your C/x86 things that you claim to map to the Turing Machine
>>> are actually the right sort of Computation, so there actually isn't a
>>> Turing Machine for them to the equivalent of.
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-24 22:27 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<OOv3J.14164$d82.1724@fx21.iad>
In reply to#39874
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?

Replace the outermost H with a real simulator to see what the input
does, It goes Simulator -> P -> H -> P -> H -> P -> H, at which point
the first H in the series stops the sequence, and returns.

Finite Recursion.

Thus when we put back the first P, it sees:

P -> H -> P -> H -> P and decides that this must be infinte, but there
actual is just one more cycle left before the next H WILL abort its
simulation.

> 
> Maybe all black cats are really white dogs?

Only by your logic.

> 
>> This actually isn't a problem so far, because H(P,P) is non-Halting and
>> the H(P,P) also gives non-halting, so that can easily be a Computable
>> Function.
>>
> 
> H(P,P) is only non-halting until at least one element of this otherwise
> infinite chain breaks the chain. It makes sense that the element that is
> not called in infinite recursion would be the one that does this.

But the algorithm of H, which is also part of the algorithm of P WILL
break the chain, so it isn't

You logic is based on presuming the existance of something that isn't
there. That doesn't count. H IS what it is, you can't evaluate P based
on some other H that built a different P.

> 
>> It just isn't a correct Halt Deciding, since when H(P,P) give P(P) that
>> non-halting answer, P(P) then halts.
>>
> 
> They are very similar looking distinctly different comutations that are
> proven to be different by their different execution trace.

If the P(P) that is run independent is a different P(P) that H is
simulating, your setup is incorrect.

PERIOD.

YOU FAIL.

> 
> H1(P,P) is a similar computation to P(P).

But H1 isn't a compuation that matters. Since H1 ISN'T H, it doesn't matter.

FAIL.

> 
>> When you then claim that H1 is the SAME Computable Function and its
>> answer is correct, then you have a problem.
>>
> 
> Whenever a halt decider must decide halting on an input that calls this
> same halt decider this is an entirely different computation than when an
> exact copy of this code must decide halting on the exact same input that
> does not call this copied halt decider.
> 

NO. Just means your decider isn't a computation and thus not a Decider.

FAIL.

> You maintain your false assumptions even when presented with easily
> verified facts to the contrary.

WHAT FACTS.

Can you actually PROVE them. As in present an ACTUAL formal proof proof
starting from standardly accepted Theorms, Axioms and Definitions?

I don't think so, all you can say is 'by the meaning or the words'
without even givening the meaning of the words.

> 
>> Or, when you claim that H's non halting answer while it might not be
>> correct for the indpendently run P(P) is correct of the P(P) is is
>> simulating, then that implies that P is not a computable function, as
>> two instances of it give diffent answers for the same input, but the
>> structure of P is such that the only way that P isn't computable is if H
>> itself isn't. The simulated P(P) can only be non halting if the
>> simulated H(P,P) doesn't answer non-halting which means that H isn't
>> actually a Computatable Function.
>>
>> If you allow H to be wrong, then it could be a Turing Machine, but it
>> just is wrong.
>>
>> If you don't allow H to be wrong, then it must not actually a Computable
>> Function, and thus doesn't map to a Turing Machine.
>>
>>>> A Computation is the running of such an algorithm on an input.
>>>>
>>>> The Turing Machine is an embodiment of an algorithm.
>>>>
>>>> Add an input tape, and you get a Computaton.
>>>>
>>>> The sum set of all input tapes to their results, is a Computable
>>>> Function.
>>>>
>>>>>
>>>>>>>
>>>>>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>>>>>> will
>>>>>>>> KNOW that if it is programmed to indicate that the computation is
>>>>>>>> recursive, that so will the H that it simulated, and thus the
>>>>>>>> recursion
>>>>>>>> here is strictly limited.
>>>>>>>>
>>>>>>>
>>>>>>> H knows that is must abort the simulation of its input because its
>>>>>>> input
>>>>>>> never reaches its final state whether or not it aborts this input.
>>>>>>
>>>>>> It may 'know' that, but it is wrong. Since H does abort its
>>>>>> simulation
>>>>>> and answer Non-Halting, the machine represented by the input will
>>>>>> reach
>>>>>> its Halting State.
>>>>>>
>>>>>>>
>>>>>>>> We can add the tracking of all calls that occur, with their
>>>>>>>> parameters,
>>>>>>>> and thus detect if its input uses recursion. We can't tell if the
>>>>>>>> recursion is infinite, but we can tell that any recursion that goes
>>>>>>>> through H with the same parameters will NOT be infinite.
>>>>>>>>
>>>>>>>> This unfortunately falls short of being a useful Halt Detector,
>>>>>>>> as a
>>>>>>>> simple simulator will not be able to tell what happens after this
>>>>>>>> simulated copy of itself will do after it aborts as that abort will
>>>>>>>> always be later in the execution of the machine that it is
>>>>>>>> simulating
>>>>>>>> than when the simulator will abort it.
>>>>>>>>
>>>>>>>> The task you want to do is proven to be impossible. Impossible to
>>>>>>>> solve
>>>>>>>> problems do exist.
>>>>>>>>
>>>>>>>> The key here is that the actual Question being asked by the Halting
>>>>>>>> Problem DOES have an answer, for any given defined machine H,
>>>>>>>> there IS
>>>>>>>> a defined machine H^ that can be built from it, and that machine
>>>>>>>> has a
>>>>>>>> definite halting status when run on a representation of itself.
>>>>>>>>
>>>>>>>> It is just demonstrable that it is impossible to design an H that
>>>>>>>> gives
>>>>>>>> the right answer for the H^ built from it. That is NOT a
>>>>>>>> contradiction,
>>>>>>>> that just shows that designed problem (which is NOT the Queston of
>>>>>>>> the
>>>>>>>> Halting Problem) is impossible. This gives us the answer to the
>>>>>>>> second
>>>>>>>> question of the Halting Problem, that it IS actually impossible to
>>>>>>>> make
>>>>>>>> a Computation that gives the right answer for EVERY possibe
>>>>>>>> Machine/Input combinations, as we show how to build amachine that
>>>>>>>> will
>>>>>>>> defeat any given machine.
>>>>>>>>
>>>>>>>
>>>>>>> All of the inputs that were defined with the liar paradox pattern
>>>>>>> require three halt deciders H1/Hx/H to detect this Liar Paradox
>>>>>>> pattern
>>>>>>> and toss out the one that loses the three-way vote.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>> If you define a decider based on 3 copies of H, and call this lets
>>>>>> say
>>>>>> H3, then you just need to make the H^ pattern based on H3, call it
>>>>>> H3^,
>>>>>> and your H3 voting pattern will get this wrong.
>>>>>>
>>>>>> I think all three will detect the infinite recursion and thus the
>>>>>> consesus will be non-halting, at which point it will halt, showing
>>>>>> them
>>>>>> ALL to be wrong, even the majority vote.
>>>>>>
>>>>>> Depending on how you do the voting, it might be possible for only
>>>>>> 2 of
>>>>>> the three to get it wrong, if H3 never checks the third machine if
>>>>>> the
>>>>>> first two agree.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> It has already been empirically validated that although the equivalent
>>>>> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
>>>>> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
>>>>> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior
>>>>> of Ĥ.
>>>>>
>>>>
>>>> Nope. You have unsound logic.
>>>>
>>>> The 'H' that gets the right answer is NOT the same 'H' that H^ was
>>>> built
>>>> on, if it was, it would get the exact same answer.
>>>>
>>>
>>> One machine has an input that calls the same halt decider that is
>>> evaluating it and the other machine does not this makea them distinctly
>>> different computations even though their code it the same.
>>
>> If they give different answers, they can't be the same Computable
>> Function. PERIOD.
>>
>> IF H/H1 can distinguish that P calls H but not H1, then they are not the
>> same Computable Function. PERIOD.
>>
>> You can't claim that they actually have the exact same algorithm, but
>> give different result from the exact same input.
>>
> 
> P calls H and P does not call H1 this makes a big difference.

SO H and H1 are different, thus they are not the same. PERIOD.

H1 can't be a 'substitute' for H. PERIOD.

To say it can is just a Damn Lie.


If H1 is ACTUALLY a exact copy of H then one of these must be true:

H1(P,P) == H(P,P), or

The algorithm actually has some extra input, so we are really comparing
the resutls of H1(P,P,x1) and H(P,P,x) which says the decider doesn't
have the right inputs to be a Halting decider, or

The algorithm isn't actually a proper algrothithm and H1 and H aren't
really Computations.

The only other possibility is that H1 and H don't actually have the
exact same algorithm in them.

PERIOD>.

SInce you won't publish the actual code, all I can do is give you the
options, you have to tell us which way it is wrong.

You can't prove you are right and keep the code secret. PERIOD.

We just know you are Lying.

> 
>> If they really DO have the same algorithm, then the 'input' described is
>> NOT the complete list of inputs, and thus they fail to be Computable
>> Fuinctions of the defined input set.
>>
>> They are a mapping of I+x => O, not I => O.
>>
>>>
>>>> This basically proves that your whole logic is flawed. Most likely
>>>> because your C/x86 things that you claim to map to the Turing Machine
>>>> are actually the right sort of Computation, so there actually isn't a
>>>> Turing Machine for them to the equivalent of.
>>>>
>>>
>>>
>>
> 
> 

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 22:36 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<zdadnY2h_8XZBNP8nZ2dnUU7-VfNnZ2d@giganews.com>
In reply to#39877
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.




-- 
Copyright 2021 Pete Olcott

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 23:31 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<yJudnR--ko-QO9P8nZ2dnUU7-fPNnZ2d@giganews.com>
In reply to#39883
On 9/24/2021 10: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.

I must correct my mistakes when I become aware of them. In this case you 
made no mistake and were only going by the title of the post. I 
apologize for my mistake.

H detects that its input never reaches its final state.

-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-25 06:06 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<JwC3J.125611$F26.32557@fx44.iad>
In reply to#39886
On 9/25/21 12:31 AM, olcott wrote:
> On 9/24/2021 10: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.
> 
> I must correct my mistakes when I become aware of them. In this case you
> made no mistake and were only going by the title of the post. I
> apologize for my mistake.
> 
> H detects that its input never reaches its final state.
> 

Again, you use that bad terminology.

Inputs don't actually DO anything.

The program P (P) that is the machine the input to H represents, does
reach its final state, and thus is a Halting Computation.


Yes, H doesn't see that state in its simulation, because it stoppeed
simulating too soon and returned the wrong answer.

PERIOD.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 09:09 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<APCdnQ5GM5sVsNL8nZ2dnUU7-LvNnZ2d@giganews.com>
In reply to#39889
On 9/25/2021 5:06 AM, Richard Damon wrote:
> On 9/25/21 12:31 AM, olcott wrote:
>> On 9/24/2021 10: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.
>>
>> I must correct my mistakes when I become aware of them. In this case you
>> made no mistake and were only going by the title of the post. I
>> apologize for my mistake.
>>
>> H detects that its input never reaches its final state.
>>
> 
> Again, you use that bad terminology.
> 

When the context has been that H is a simulating halt decider that 
simulates its input and I have told you this at least a thousand times 
pretending to forget that I said this is a real jackass move.

> Inputs don't actually DO anything.
> 
> The program P (P) that is the machine the input to H represents, does
> reach its final state, and thus is a Halting Computation.
> 

It is a verifiable fact that the input to H(P,P) cannot possibly reach 
its final state whether or not H stops simulating it. It is a verifiable 
fact that H does simulate P(P) correctly. That you disagree without 
knowing the x86 language well enough to comprehend the proof that I am 
correct is a real jackass move.

> 
> Yes, H doesn't see that state in its simulation, because it stoppeed
> simulating too soon and returned the wrong answer.
> 
> PERIOD.
> 

You are being a jackass. Please stop.


-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-25 12:09 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<kRH3J.1162$2m1.716@fx26.iad>
In reply to#39895
On 9/25/21 10:09 AM, olcott wrote:
> On 9/25/2021 5:06 AM, Richard Damon wrote:
>> On 9/25/21 12:31 AM, olcott wrote:
>>> On 9/24/2021 10: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.
>>>
>>> I must correct my mistakes when I become aware of them. In this case you
>>> made no mistake and were only going by the title of the post. I
>>> apologize for my mistake.
>>>
>>> H detects that its input never reaches its final state.
>>>
>>
>> Again, you use that bad terminology.
>>
> 
> When the context has been that H is a simulating halt decider that
> simulates its input and I have told you this at least a thousand times
> pretending to forget that I said this is a real jackass move.

But since you keep on saying that even though the machine that the input
represents is admittdly halting, somehow 'the input' isn't, so you can't
be using the standard definiton.

> 
>> Inputs don't actually DO anything.
>>
>> The program P (P) that is the machine the input to H represents, does
>> reach its final state, and thus is a Halting Computation.
>>
> 
> It is a verifiable fact that the input to H(P,P) cannot possibly reach
> its final state whether or not H stops simulating it. It is a verifiable
> fact that H does simulate P(P) correctly. That you disagree without
> knowing the x86 language well enough to comprehend the proof that I am
> correct is a real jackass move.


Again, you misuse the term. Inputs don't do anything.

When H does abort its simulation of its input, then the machine that the
simulation represent does halt. That is a fact.

Yes, the SIMULATION  of the input doesn't get to that state, but that is
the PARTIAL SIMULATION of the input.

Neither of these is 'the input', but two different things that the input
can represent.

The FIRST (The actual machine) is what the theory says you should be
looking at, but the second is what you seem to be doing.

Claiming that your phrase 'The Input' means what it needs to is just a LIE.


> 
>>
>> Yes, H doesn't see that state in its simulation, because it stoppeed
>> simulating too soon and returned the wrong answer.
>>
>> PERIOD.
>>
> 
> You are being a jackass. Please stop.
> 
> 

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-25 11:18 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<sYednff1iP8m1tL8nZ2dnUU7-a3NnZ2d@giganews.com>
In reply to#39898
On 9/25/2021 11:09 AM, Richard Damon wrote:
> On 9/25/21 10:09 AM, olcott wrote:
>> On 9/25/2021 5:06 AM, Richard Damon wrote:
>>> On 9/25/21 12:31 AM, olcott wrote:
>>>> On 9/24/2021 10: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.
>>>>
>>>> I must correct my mistakes when I become aware of them. In this case you
>>>> made no mistake and were only going by the title of the post. I
>>>> apologize for my mistake.
>>>>
>>>> H detects that its input never reaches its final state.
>>>>
>>>
>>> Again, you use that bad terminology.
>>>
>>
>> When the context has been that H is a simulating halt decider that
>> simulates its input and I have told you this at least a thousand times
>> pretending to forget that I said this is a real jackass move.
> 
> But since you keep on saying that even though the machine that the input
> represents is admittdly halting, somehow 'the input' isn't, so you can't
> be using the standard definiton.
> 
>>
>>> Inputs don't actually DO anything.
>>>
>>> The program P (P) that is the machine the input to H represents, does
>>> reach its final state, and thus is a Halting Computation.
>>>
>>
>> It is a verifiable fact that the input to H(P,P) cannot possibly reach
>> its final state whether or not H stops simulating it. It is a verifiable
>> fact that H does simulate P(P) correctly. That you disagree without
>> knowing the x86 language well enough to comprehend the proof that I am
>> correct is a real jackass move.
> 
> 
> Again, you misuse the term. Inputs don't do anything.
> 
> When H does abort its simulation of its input, then the machine that the
> simulation represent does halt. That is a fact.
> 

That is a subtle dishonest dodge strawman error.

int main() { H(P,P); } is a distinctly different computation than
int main() { P(P); }
int main() { H1(P,P); } is equivalent to int main() { P(P); }



-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-25 12:24 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<f3I3J.203346$T_8.196429@fx48.iad>
In reply to#39902
On 9/25/21 12:18 PM, olcott wrote:
> On 9/25/2021 11:09 AM, Richard Damon wrote:
>> On 9/25/21 10:09 AM, olcott wrote:
>>> On 9/25/2021 5:06 AM, Richard Damon wrote:
>>>> On 9/25/21 12:31 AM, olcott wrote:
>>>>> On 9/24/2021 10: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.
>>>>>
>>>>> I must correct my mistakes when I become aware of them. In this
>>>>> case you
>>>>> made no mistake and were only going by the title of the post. I
>>>>> apologize for my mistake.
>>>>>
>>>>> H detects that its input never reaches its final state.
>>>>>
>>>>
>>>> Again, you use that bad terminology.
>>>>
>>>
>>> When the context has been that H is a simulating halt decider that
>>> simulates its input and I have told you this at least a thousand times
>>> pretending to forget that I said this is a real jackass move.
>>
>> But since you keep on saying that even though the machine that the input
>> represents is admittdly halting, somehow 'the input' isn't, so you can't
>> be using the standard definiton.
>>
>>>
>>>> Inputs don't actually DO anything.
>>>>
>>>> The program P (P) that is the machine the input to H represents, does
>>>> reach its final state, and thus is a Halting Computation.
>>>>
>>>
>>> It is a verifiable fact that the input to H(P,P) cannot possibly reach
>>> its final state whether or not H stops simulating it. It is a verifiable
>>> fact that H does simulate P(P) correctly. That you disagree without
>>> knowing the x86 language well enough to comprehend the proof that I am
>>> correct is a real jackass move.
>>
>>
>> Again, you misuse the term. Inputs don't do anything.
>>
>> When H does abort its simulation of its input, then the machine that the
>> simulation represent does halt. That is a fact.
>>
> 
> That is a subtle dishonest dodge strawman error.
> 
> int main() { H(P,P); } is a distinctly different computation than
> int main() { P(P); }
> int main() { H1(P,P); } is equivalent to int main() { P(P); }
> 
> 
> 

Right, H(P,P) is not the SAME COMPUTATION as P(P) but is a decider whose
answer is supposed to predict what the second does.

H1(P,P) is another decider. Since P is built for H and not H1, the Linz
proof only talks about what H can't do, and the fact that H and H1 give
different answers says they are NOT the same thing, so H1 getting it
right doesn't matter.

All you claims to the contrary just show you are lying about something.

Either their code isn't the same, or
The code takes some other hidden input which is different, so H/H1 is
disqualified to be the Halt Decider since it isn't the right form, or

The code for H/H1 isn't actually a computation because it isn't a
complete 'algorithm'.

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-25 06:03 -0400
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<otC3J.61946$tG6.35640@fx39.iad>
In reply to#39883
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.

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]


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

Back to top | Article view | comp.theory


csiph-web