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


#39791 — Is it possible to create a simple infinite emulation detector?

Fromolcott <NoOne@NoWhere.com>
Date2021-09-23 13:30 -0500
SubjectIs it possible to create a simple infinite emulation detector?
Message-ID<eP2dnfJCwLgqWtH8nZ2dnUU7-YPNnZ2d@giganews.com>
#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.


-- 
Copyright 2021 Pete Olcott

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

[toc] | [next] | [standalone]


#39794

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-23 19:17 -0600
Message-ID<sij8vv$jnq$1@dont-email.me>
In reply to#39791
On 2021-09-23 12:30, 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.

An emulator doesn't *need* to run in debug step mode since the emulator 
can put whatever instructions it wants between the emulated instructions.

> 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.

Right now your solution seems to consist of the line:

// Determine infinitely nested x86 emulation

That's not exactly something which can be critiqued in any detail.

André

-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#39796

Fromolcott <NoOne@NoWhere.com>
Date2021-09-23 20:25 -0500
Message-ID<rpOdnU9-ILFrtdD8nZ2dnUU7-eHNnZ2d@giganews.com>
In reply to#39794
On 9/23/2021 8:17 PM, André G. Isaak wrote:
> On 2021-09-23 12:30, 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.
> 
> An emulator doesn't *need* to run in debug step mode since the emulator 
> can put whatever instructions it wants between the emulated instructions.
> 

A simulating halt decider does not know in advance the exact point in 
the emulation of the input program where a non-halting behavior pattern 
is matched. Because of this it tests to see if a non-halting behavior 
pattern has been matched after emulating each instruction of the input.

>> 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.
> 
> Right now your solution seems to consist of the line:
> 
> // Determine infinitely nested x86 emulation
> 
> That's not exactly something which can be critiqued in any detail.
> 
> André
> 

My question is can you prove that solving this specific problem is 
impossible? It seems like everyone here acts as if solving the very 
simple problem is necessarily totally impossible.

-- 
Copyright 2021 Pete Olcott

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

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


#39802

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-23 19:58 -0600
Message-ID<sijbd3$vfs$1@dont-email.me>
In reply to#39796
On 2021-09-23 19:25, olcott wrote:
> On 9/23/2021 8:17 PM, André G. Isaak wrote:
>> On 2021-09-23 12:30, 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.
>>
>> An emulator doesn't *need* to run in debug step mode since the 
>> emulator can put whatever instructions it wants between the emulated 
>> instructions.
>>
> 
> A simulating halt decider does not know in advance the exact point in 
> the emulation of the input program where a non-halting behavior pattern 
> is matched. Because of this it tests to see if a non-halting behavior 
> pattern has been matched after emulating each instruction of the input.

Yes, and an emulator can single-step through the code it is emulated 
without debug step mode being involved. You do grasp that debug-step 
mode is used for software which is being *directly* executed by the 
processor and involves a hardware interrupt, right? An emulator doesn't 
require this.

>>> 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.
>>
>> Right now your solution seems to consist of the line:
>>
>> // Determine infinitely nested x86 emulation
>>
>> That's not exactly something which can be critiqued in any detail.
>>
>> André
>>
> 
> My question is can you prove that solving this specific problem is 
> impossible? It seems like everyone here acts as if solving the very 
> simple problem is necessarily totally impossible.

Linz has already done so. You are the one to claim to have shown 
otherwise, but all you give is a line of comment. It isn't incumbent on 
us to prove you wrong. It is incumbent on you to prove that you actually 
have a solution.

André

-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#39811

Fromolcott <NoOne@NoWhere.com>
Date2021-09-23 22:13 -0500
Message-ID<5d-dnSEaYdbt39D8nZ2dnUU7-XXNnZ2d@giganews.com>
In reply to#39802
On 9/23/2021 8:58 PM, André G. Isaak wrote:
> On 2021-09-23 19:25, olcott wrote:
>> On 9/23/2021 8:17 PM, André G. Isaak wrote:
>>> On 2021-09-23 12:30, 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.
>>>
>>> An emulator doesn't *need* to run in debug step mode since the 
>>> emulator can put whatever instructions it wants between the emulated 
>>> instructions.
>>>
>>
>> A simulating halt decider does not know in advance the exact point in 
>> the emulation of the input program where a non-halting behavior 
>> pattern is matched. Because of this it tests to see if a non-halting 
>> behavior pattern has been matched after emulating each instruction of 
>> the input.
> 
> Yes, and an emulator can single-step through the code it is emulated 
> without debug step mode being involved. You do grasp that debug-step 
> mode is used for software which is being *directly* executed by the 
> processor and involves a hardware interrupt, right? An emulator doesn't 
> require this.
> 

I used a common term to that there would be common understanding.
It is much more cocise to simply call this debug step mode. People know 
what that means.

>>>> 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.
>>>
>>> Right now your solution seems to consist of the line:
>>>
>>> // Determine infinitely nested x86 emulation
>>>
>>> That's not exactly something which can be critiqued in any detail.
>>>
>>> André
>>>
>>
>> My question is can you prove that solving this specific problem is 
>> impossible? It seems like everyone here acts as if solving the very 
>> simple problem is necessarily totally impossible.
> 
> Linz has already done so. You are the one to claim to have shown 
> otherwise, but all you give is a line of comment. It isn't incumbent on 
> us to prove you wrong. It is incumbent on you to prove that you actually 
> have a solution.
> 
> André
> 

#include <stdint.h>
#define ptr uintptr_t

void P(ptr x)
{
   H(x, x);
}

int main()
{
   Output("Input_Halts = ", H(P, P));
}

Linz has proved it is totally impossible to create a C function named H 
that emulates P(P) with an x86 emulator to determine from the execution 
trace of P that P never reaches its final state?

I think that most very well qualified software engineers that know C and 
the x86 language very well would disagree.

-- 
Copyright 2021 Pete Olcott

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

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


#39817

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-23 23:25 -0400
Message-ID<Fyb3J.17091$2e3.12544@fx29.iad>
In reply to#39811
On 9/23/21 11:13 PM, olcott wrote:
> On 9/23/2021 8:58 PM, André G. Isaak wrote:
>> On 2021-09-23 19:25, olcott wrote:
>>> On 9/23/2021 8:17 PM, André G. Isaak wrote:
>>>> On 2021-09-23 12:30, 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.
>>>>
>>>> An emulator doesn't *need* to run in debug step mode since the
>>>> emulator can put whatever instructions it wants between the emulated
>>>> instructions.
>>>>
>>>
>>> A simulating halt decider does not know in advance the exact point in
>>> the emulation of the input program where a non-halting behavior
>>> pattern is matched. Because of this it tests to see if a non-halting
>>> behavior pattern has been matched after emulating each instruction of
>>> the input.
>>
>> Yes, and an emulator can single-step through the code it is emulated
>> without debug step mode being involved. You do grasp that debug-step
>> mode is used for software which is being *directly* executed by the
>> processor and involves a hardware interrupt, right? An emulator
>> doesn't require this.
>>
> 
> I used a common term to that there would be common understanding.
> It is much more cocise to simply call this debug step mode. People know
> what that means.

Which isn't simulation.

Also, rarely is a debugger able to use this mode on itself, as it
appears that you are doing.

> 
>>>>> 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.
>>>>
>>>> Right now your solution seems to consist of the line:
>>>>
>>>> // Determine infinitely nested x86 emulation
>>>>
>>>> That's not exactly something which can be critiqued in any detail.
>>>>
>>>> André
>>>>
>>>
>>> My question is can you prove that solving this specific problem is
>>> impossible? It seems like everyone here acts as if solving the very
>>> simple problem is necessarily totally impossible.
>>
>> Linz has already done so. You are the one to claim to have shown
>> otherwise, but all you give is a line of comment. It isn't incumbent
>> on us to prove you wrong. It is incumbent on you to prove that you
>> actually have a solution.
>>
>> André
>>
> 
> #include <stdint.h>
> #define ptr uintptr_t
> 
> void P(ptr x)
> {
>   H(x, x);
> }
> 
> int main()
> {
>   Output("Input_Halts = ", H(P, P));
> }
> 
> Linz has proved it is totally impossible to create a C function named H
> that emulates P(P) with an x86 emulator to determine from the execution
> trace of P that P never reaches its final state?
> 
> I think that most very well qualified software engineers that know C and
> the x86 language very well would disagree.
> 

Since when we use that same P and call it from main, it DOES reach its
final state, it shows the claim that the actual execution of the REAL
program P(P) is non-halting is incorrect, as P(P) is clearly seen, and
admitted by you, to be Halting.

If we look at the execution trace of this P(P) we see that it begins
exactly like the trace that H recorded and claimed is proof that it is
non-halting showing the claim to be invalid.

The 'logic' used to make this claim has also been demonstrated to be
unsound.

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


#39823

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-23 21:38 -0600
Message-ID<sijh71$8mp$1@dont-email.me>
In reply to#39811
On 2021-09-23 21:13, olcott wrote:
> On 9/23/2021 8:58 PM, André G. Isaak wrote:

>> Yes, and an emulator can single-step through the code it is emulated 
>> without debug step mode being involved. You do grasp that debug-step 
>> mode is used for software which is being *directly* executed by the 
>> processor and involves a hardware interrupt, right? An emulator 
>> doesn't require this.
>>
> 
> I used a common term to that there would be common understanding.

You used a common term to mean something other than what that common 
term actually means. That's not how you achieve common understanding.

> It is much more cocise to simply call this debug step mode. People know 
> what that means.

Yes, people other than you do know what it means. It means directly 
executing a program on the hardware (not simulating it) with the 
processor in a specific mode which causes the CPU to generates an INT1 
interrupt following the execution of every instruction which transfers 
control to the debugger. If that's not what you're doing, then don't 
call it that.

André

-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#39806

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-23 22:14 -0400
Message-ID<rwa3J.19809$Im6.19587@fx09.iad>
In reply to#39796
On 9/23/21 9:25 PM, olcott wrote:
> On 9/23/2021 8:17 PM, André G. Isaak wrote:
>> On 2021-09-23 12:30, 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.
>>
>> An emulator doesn't *need* to run in debug step mode since the
>> emulator can put whatever instructions it wants between the emulated
>> instructions.
>>
> 
> A simulating halt decider does not know in advance the exact point in
> the emulation of the input program where a non-halting behavior pattern
> is matched. Because of this it tests to see if a non-halting behavior
> pattern has been matched after emulating each instruction of the input.

I think the comment is that your use of the name 'Debug Step' implies
the use of the debug trap for actually EXECUTION the input code as
opposed to having a 'Simulation Step' command.

From all your comments, it sounds like the input is actually being
executed and not just simulated, since it seems that the simulated
copies of H have access to the state of the simulator (which is
impossible for a real simulator).

> 
>>> 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.
>>
>> Right now your solution seems to consist of the line:
>>
>> // Determine infinitely nested x86 emulation
>>
>> That's not exactly something which can be critiqued in any detail.
>>
>> André
>>
> 
> My question is can you prove that solving this specific problem is
> impossible? It seems like everyone here acts as if solving the very
> simple problem is necessarily totally impossible.
> 

Linz. NO Halt decider (simulating or otherwise) can correctly decide the
H^ Machine derived from it.

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


#39799

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-24 02:42 +0100
Message-ID<87lf3mzr35.fsf@bsb.me.uk>
In reply to#39791
olcott <NoOne@NoWhere.com> writes:

> #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.

All x86 programs (of the kind you appear to be talking about without
unbounded input) have a finite number of configurations.  All
"interesting" properties of them are decidable.  In fact, there are only
a finite number of them to start with.  There is nothing of interest
here.

-- 
Ben.

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


#39803

Fromolcott <NoOne@NoWhere.com>
Date2021-09-23 21:01 -0500
Message-ID<ou2dnZApoZQJrND8nZ2dnUU7-XvNnZ2d@giganews.com>
In reply to#39799
On 9/23/2021 8:42 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> #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.
> 
> All x86 programs (of the kind you appear to be talking about without
> unbounded input) have a finite number of configurations.  All
> "interesting" properties of them are decidable.  In fact, there are only
> a finite number of them to start with.  There is nothing of interest
> here.
> 

That you don't know enough software engineering to appreciate that some 
variation of this is equivalent to refuting the halting theorem is of no 
consequence. I need actual honest critique not baseless naysayers. That 
you don't provide a basis is because your understanding does not go deep 
enough to provide a basis.

-- 
Copyright 2021 Pete Olcott

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

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


#39804

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-24 03:03 +0100
Message-ID<87fstuzq4q.fsf@bsb.me.uk>
In reply to#39803
olcott <NoOne@NoWhere.com> writes:

> On 9/23/2021 8:42 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> #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.
>>
>> All x86 programs (of the kind you appear to be talking about without
>> unbounded input) have a finite number of configurations.  All
>> "interesting" properties of them are decidable.  In fact, there are only
>> a finite number of them to start with.  There is nothing of interest
>> here.
>
> That you don't know enough software engineering to appreciate that
> some variation of this is equivalent to refuting the halting theorem
> is of no consequence. I need actual honest critique not baseless
> naysayers. That you don't provide a basis is because your
> understanding does not go deep enough to provide a basis.

Carry on wasting your time on a finite model.  It's no skin off my nose.

-- 
Ben.

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


#39805

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-23 22:09 -0400
Message-ID<dra3J.78902$Dr.49576@fx40.iad>
In reply to#39791
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.

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.

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.

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


#39819

Fromolcott <NoOne@NoWhere.com>
Date2021-09-23 22:27 -0500
Message-ID<2NydnbC8WNAD2ND8nZ2dnUU7-f3NnZ2d@giganews.com>
In reply to#39805
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.

> 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.

> 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.


-- 
Copyright 2021 Pete Olcott

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

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


#39824

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-23 23:39 -0400
Message-ID<eMb3J.17462$YG4.1741@fx15.iad>
In reply to#39819
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.

> 
>> 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.

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


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

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

>>
>>> 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 Ĥ.


-- 
Copyright 2021 Pete Olcott

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

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-24 21:54 +0100
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<87lf3ly9r2.fsf@bsb.me.uk>
In reply to#39834
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.

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-09-24 16:53 -0500
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<PJ-dndR6J8ZQ1dP8nZ2dnUU7-cNQAAAA@giganews.com>
In reply to#39842
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.

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.

Since Linz does not exclude simulating halt deciders this is still the 
Linz Ĥ.


-- 
Copyright 2021 Pete Olcott

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

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-25 00:22 +0100
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<87v92pwod0.fsf@bsb.me.uk>
In reply to#39847
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?

-- 
Ben.

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


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

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

-- 
Copyright 2021 Pete Olcott

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

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-25 21:43 +0100
SubjectRe: Is it possible to create a simple infinite emulation detector? [ cite sources ]
Message-ID<87r1dcv12c.fsf@bsb.me.uk>
In reply to#39861
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.

-- 
Ben.

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


Page 1 of 4  [1] 2 3 4  Next page →

Back to top | Article view | comp.theory


csiph-web