Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #39791 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-09-23 13:30 -0500 |
| Last post | 2021-09-26 06:39 -0400 |
| Articles | 20 on this page of 64 — 6 participants |
Back to article view | Back to comp.theory
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 →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-23 13:30 -0500 |
| Subject | Is 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]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-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]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-24 09:49 -0500 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-24 21:54 +0100 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-24 16:53 -0500 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-25 00:22 +0100 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-24 19:01 -0500 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-09-25 21:43 +0100 |
| Subject | Re: 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