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


Groups > comp.theory > #39507 > unrolled thread

Must a partial halt decider be a pure function of its inputs?

Started byolcott <NoOne@NoWhere.com>
First post2021-09-18 22:42 -0500
Last post2021-09-20 19:35 -0400
Articles 20 on this page of 62 — 8 participants

Back to article view | Back to comp.theory


Contents

  Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-18 22:42 -0500
    Re: Must a partial halt decider be a pure function of its inputs? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-19 02:30 -0700
      Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-19 06:09 -0500
        Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 08:15 -0400
          Re: Must a partial halt decider be a pure function of its inputs? [ decidability decider ] olcott <NoOne@NoWhere.com> - 2021-09-19 10:03 -0500
            Re: Must a partial halt decider be a pure function of its inputs? [ decidability decider ] Richard Damon <Richard@Damon-Family.org> - 2021-09-19 13:47 -0400
            Re: Must a partial halt decider be a pure function of its inputs? [ decidability decider ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 23:42 +0100
    Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 06:39 -0400
      Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-19 06:25 -0500
        Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 08:12 -0400
          Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-19 09:48 -0500
            Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 13:58 -0400
    Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 11:20 -0500
      Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 19:05 +0100
        Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 13:16 -0500
          Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 19:29 +0100
            Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 13:40 -0500
              Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 19:44 +0100
                Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 14:04 -0500
                  Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 20:13 +0100
                    Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 14:27 -0500
                      Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 20:29 +0100
                        Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 15:08 -0500
                          Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 21:32 +0100
                  Re: Must a partial halt decider be a pure function of its inputs? (addendum) Richard Damon <Richard@Damon-Family.org> - 2021-09-19 19:16 -0400
      Re: Must a partial halt decider be a pure function of its inputs? (addendum) Richard Damon <Richard@Damon-Family.org> - 2021-09-19 14:05 -0400
        Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 13:21 -0500
          Re: Must a partial halt decider be a pure function of its inputs? (addendum) Richard Damon <news.x.richarddamon@xoxy.net> - 2021-09-19 14:51 -0400
            Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 14:14 -0500
              Re: Must a partial halt decider be a pure function of its inputs? (addendum) André G. Isaak <agisaak@gm.invalid> - 2021-09-19 13:41 -0600
    Re: Must a partial halt decider be a pure function of its inputs? Charlie-Boo <shymathguy@gmail.com> - 2021-09-20 09:15 -0700
      Re: Must a partial halt decider be a pure function of its inputs? Charlie-Boo <shymathguy@gmail.com> - 2021-09-20 09:34 -0700
        Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 11:46 -0500
      Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 11:44 -0500
        Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 11:17 -0600
          Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 12:42 -0500
            Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 11:59 -0600
              Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 13:59 -0500
                Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 14:01 -0600
                  Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 15:46 -0500
                    Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 15:07 -0600
                      Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 16:52 -0500
                        Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 16:06 -0600
                          Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 17:29 -0500
                            Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 16:52 -0600
                              Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 18:17 -0500
            Re: Must a partial halt decider be a pure function of its inputs? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 23:06 +0100
              Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 17:37 -0500
                Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:31 -0400
                  Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 18:48 -0500
                    Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:38 -0400
                      Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 21:45 -0500
                        Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:27 -0400
                        Re: Must a partial halt decider be a pure function of its inputs? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-20 23:14 -0700
                          Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-21 09:39 -0500
                            Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-21 19:16 -0400
                Re: Must a partial halt decider be a pure function of its inputs? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 01:45 +0100
                  Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 19:53 -0500
                    Re: Must a partial halt decider be a pure function of its inputs? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 02:39 +0100
                      Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 20:44 -0500
                        Re: Must a partial halt decider be a pure function of its inputs? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:33 +0100
            Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:35 -0400

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


#39624

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-20 15:07 -0600
Message-ID<siat5v$ubi$1@dont-email.me>
In reply to#39623
On 2021-09-20 14:46, olcott wrote:
> On 9/20/2021 3:01 PM, André G. Isaak wrote:
>> On 2021-09-20 12:59, olcott wrote:
>>> On 9/20/2021 12:59 PM, André G. Isaak wrote:
>>
>>>> But, as I have pointed out previously, and which you ignored, you 
>>>> are then claiming that your *real* halt decider is the combination 
>>>> of H, H1, Hx and your 'decidability decider'.
>>>>
>>>
>>> Yes.
>>>
>>>> In that case your P must be derived from that *combination* if you 
>>>> want to claim that it is analogous to Linz's H_Hat.
>>>>
>>>
>>> No Olcott H1,H,Hx is superior to anything that Linz said because 
>>> there is no input that it cannot decide.
>>
>> So show us the actual code for this new routine. I know you are never 
>> going to reveal the code for your H, but you can at least show the 
>> code for this combination routine which calls H, H1 and Hx and returns 
>> true for halting and false for non-halting.
>>
>> Then show the code for the hat construction derived from this new 
>> decider and show how this decider can correctly decide that hat 
>> construction.
>>
> 
> Before I show any code I have to have my use of static local data 
> validated as acceptable.

It won't be 'validated' because it simply isn't allowed. As Richard has 
pointed out the mere presence of a static variable doesn't necessarily 
rule out something as a computation if it is simply there for 
efficiency's sake, but if the routine actually *depends* on the use of a 
static variable so that difference invocations have access to different 
information, then you're not dealing with a computation.

>>>> The whole point of the Linz proof is that for *any* 'halt decider' 
>>>> X, one can always construct an X_Hat which it cannot decide 
>>>> correctly. Your combined H+H1+Hx+DD is just as susceptible to this 
>>>> as any other putative 'halt decider'.
>>>>
>>>> André
>>>>
>>>
>>> The whole point of all these proofs is that no universal halt decider 
>>> exists. The Olcott combination of H1,H,Hx is such a universal halt 
>>> decider that is purported to not exist.
>>>
>>> The key breakthrough is that Rice's theorem "proved" that no 
>>> decidability decider can possibly exist thus once we have such a 
>>> decidability decider Rice's theorem and the halting theorem both fail.
>>
>> You don't seem to understand what Rice's theorem actually states.
>>
>> André
>>
> 
> Historically on comp.theory this has meant that it is impossible to 
> create a TM the rejects undecidable inputs.

What do you mean by an 'undecidable input'? Input to what?

Rice's theorem says you can't create a TM X which decides some 
nontrivial semantic property of an arbitary Turing Machine Y (or of the 
language accepted by Y). Once you start talking about 'inputs' you are 
talking about computations rather than Turing Machines.

André

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

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


#39626

Fromolcott <NoOne@NoWhere.com>
Date2021-09-20 16:52 -0500
Message-ID<aP2dnWvpR-8kn9T8nZ2dnUU7-SPNnZ2d@giganews.com>
In reply to#39624
On 9/20/2021 4:07 PM, André G. Isaak wrote:
> On 2021-09-20 14:46, olcott wrote:
>> On 9/20/2021 3:01 PM, André G. Isaak wrote:
>>> On 2021-09-20 12:59, olcott wrote:
>>>> On 9/20/2021 12:59 PM, André G. Isaak wrote:
>>>
>>>>> But, as I have pointed out previously, and which you ignored, you 
>>>>> are then claiming that your *real* halt decider is the combination 
>>>>> of H, H1, Hx and your 'decidability decider'.
>>>>>
>>>>
>>>> Yes.
>>>>
>>>>> In that case your P must be derived from that *combination* if you 
>>>>> want to claim that it is analogous to Linz's H_Hat.
>>>>>
>>>>
>>>> No Olcott H1,H,Hx is superior to anything that Linz said because 
>>>> there is no input that it cannot decide.
>>>
>>> So show us the actual code for this new routine. I know you are never 
>>> going to reveal the code for your H, but you can at least show the 
>>> code for this combination routine which calls H, H1 and Hx and 
>>> returns true for halting and false for non-halting.
>>>
>>> Then show the code for the hat construction derived from this new 
>>> decider and show how this decider can correctly decide that hat 
>>> construction.
>>>
>>
>> Before I show any code I have to have my use of static local data 
>> validated as acceptable.
> 
> It won't be 'validated' because it simply isn't allowed. As Richard has 
> pointed out the mere presence of a static variable doesn't necessarily 
> rule out something as a computation if it is simply there for 
> efficiency's sake, but if the routine actually *depends* on the use of a 
> static variable so that difference invocations have access to different 
> information, then you're not dealing with a computation.
> 

Therefore a TM cannot possibly determine whether or not it is being 
infinitely simulated because it is required to make sure that it erases 
the execution trace that it stored between recursive simulations.

This weirdly enough would show that C is strictly more powerful than a 
TM, thus you and Richard are probably wrong.

>>>>> The whole point of the Linz proof is that for *any* 'halt decider' 
>>>>> X, one can always construct an X_Hat which it cannot decide 
>>>>> correctly. Your combined H+H1+Hx+DD is just as susceptible to this 
>>>>> as any other putative 'halt decider'.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> The whole point of all these proofs is that no universal halt 
>>>> decider exists. The Olcott combination of H1,H,Hx is such a 
>>>> universal halt decider that is purported to not exist.
>>>>
>>>> The key breakthrough is that Rice's theorem "proved" that no 
>>>> decidability decider can possibly exist thus once we have such a 
>>>> decidability decider Rice's theorem and the halting theorem both fail.
>>>
>>> You don't seem to understand what Rice's theorem actually states.
>>>
>>> André
>>>
>>
>> Historically on comp.theory this has meant that it is impossible to 
>> create a TM the rejects undecidable inputs.
> 
> What do you mean by an 'undecidable input'? Input to what?
> 
> Rice's theorem says you can't create a TM X which decides some 
> nontrivial semantic property of an arbitary Turing Machine Y (or of the 
> language accepted by Y). Once you start talking about 'inputs' you are 
> talking about computations rather than Turing Machines.
> 
> André
> 

H1 decides that H cannot correctly decide the halting status of P.

-- 
Copyright 2021 Pete Olcott

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

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


#39629

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-20 16:06 -0600
Message-ID<sib0ll$13s$1@dont-email.me>
In reply to#39626
On 2021-09-20 15:52, olcott wrote:
> On 9/20/2021 4:07 PM, André G. Isaak wrote:
>> On 2021-09-20 14:46, olcott wrote:
>>> On 9/20/2021 3:01 PM, André G. Isaak wrote:
>>>> On 2021-09-20 12:59, olcott wrote:
>>>>> On 9/20/2021 12:59 PM, André G. Isaak wrote:
>>>> 
>>>>>> But, as I have pointed out previously, and which you
>>>>>> ignored, you are then claiming that your *real* halt
>>>>>> decider is the combination of H, H1, Hx and your
>>>>>> 'decidability decider'.
>>>>>> 
>>>>> 
>>>>> Yes.
>>>>> 
>>>>>> In that case your P must be derived from that *combination*
>>>>>> if you want to claim that it is analogous to Linz's H_Hat.
>>>>>> 
>>>>> 
>>>>> No Olcott H1,H,Hx is superior to anything that Linz said
>>>>> because there is no input that it cannot decide.
>>>> 
>>>> So show us the actual code for this new routine. I know you are
>>>>  never going to reveal the code for your H, but you can at
>>>> least show the code for this combination routine which calls H,
>>>> H1 and Hx and returns true for halting and false for
>>>> non-halting.
>>>> 
>>>> Then show the code for the hat construction derived from this
>>>> new decider and show how this decider can correctly decide that
>>>> hat construction.
>>>> 
>>> 
>>> Before I show any code I have to have my use of static local data
>>>  validated as acceptable.
>> 
>> It won't be 'validated' because it simply isn't allowed. As Richard
>>  has pointed out the mere presence of a static variable doesn't 
>> necessarily rule out something as a computation if it is simply
>> there for efficiency's sake, but if the routine actually *depends*
>> on the use of a static variable so that difference invocations have
>> access to different information, then you're not dealing with a
>> computation.
>> 
> 
> Therefore a TM cannot possibly determine whether or not it is being 
> infinitely simulated because it is required to make sure that it
> erases the execution trace that it stored between recursive
> simulations.

And? The fact that you really want to be able to do something isn't an 
argument that that thing is actually doable.

> This weirdly enough would show that C is strictly more powerful than
> a TM, thus you and Richard are probably wrong.

No, it doesn't show this at all.

There are no computations which can be done in C which cannot also be 
done by a Turing Machine. The problem is that you are dealing with 
something that isn't a computation. We *could* convert this to a 
computation by supplying your 'execution trace' as a formal input 
parameter, but then you wouldn't be dealing with the halting problem 
since that problem defines a halt decider as taking a specific set of 
inputs which does not include an 'execution trace'.

>>>>>> The whole point of the Linz proof is that for *any* 'halt
>>>>>> decider' X, one can always construct an X_Hat which it
>>>>>> cannot decide correctly. Your combined H+H1+Hx+DD is just
>>>>>> as susceptible to this as any other putative 'halt
>>>>>> decider'.
>>>>>> 
>>>>>> André
>>>>>> 
>>>>> 
>>>>> The whole point of all these proofs is that no universal halt
>>>>>  decider exists. The Olcott combination of H1,H,Hx is such a
>>>>>  universal halt decider that is purported to not exist.
>>>>> 
>>>>> The key breakthrough is that Rice's theorem "proved" that no
>>>>>  decidability decider can possibly exist thus once we have
>>>>> such a decidability decider Rice's theorem and the halting
>>>>> theorem both fail.
>>>> 
>>>> You don't seem to understand what Rice's theorem actually
>>>> states.
>>>> 
>>>> André
>>>> 
>>> 
>>> Historically on comp.theory this has meant that it is impossible
>>> to create a TM the rejects undecidable inputs.
>> 
>> What do you mean by an 'undecidable input'? Input to what?
>> 
>> Rice's theorem says you can't create a TM X which decides some 
>> nontrivial semantic property of an arbitary Turing Machine Y (or of
>>  the language accepted by Y). Once you start talking about 'inputs'
>> you are talking about computations rather than Turing Machines.
>> 
>> André
>> 
> 
> H1 decides that H cannot correctly decide the halting status of P.

Which is neither a property of H nor of P but a statement about the 
specific computation H(P, P).

Rice's theorem is concerned with semantic properties of Turing Machines, 
not of specific computations.

André

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

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


#39631

Fromolcott <NoOne@NoWhere.com>
Date2021-09-20 17:29 -0500
Message-ID<5v6dnbSUA_bEltT8nZ2dnUU7-N_NnZ2d@giganews.com>
In reply to#39629
On 9/20/2021 5:06 PM, André G. Isaak wrote:
> On 2021-09-20 15:52, olcott wrote:
>> On 9/20/2021 4:07 PM, André G. Isaak wrote:
>>> On 2021-09-20 14:46, olcott wrote:
>>>> On 9/20/2021 3:01 PM, André G. Isaak wrote:
>>>>> On 2021-09-20 12:59, olcott wrote:
>>>>>> On 9/20/2021 12:59 PM, André G. Isaak wrote:
>>>>>
>>>>>>> But, as I have pointed out previously, and which you
>>>>>>> ignored, you are then claiming that your *real* halt
>>>>>>> decider is the combination of H, H1, Hx and your
>>>>>>> 'decidability decider'.
>>>>>>>
>>>>>>
>>>>>> Yes.
>>>>>>
>>>>>>> In that case your P must be derived from that *combination*
>>>>>>> if you want to claim that it is analogous to Linz's H_Hat.
>>>>>>>
>>>>>>
>>>>>> No Olcott H1,H,Hx is superior to anything that Linz said
>>>>>> because there is no input that it cannot decide.
>>>>>
>>>>> So show us the actual code for this new routine. I know you are
>>>>>  never going to reveal the code for your H, but you can at
>>>>> least show the code for this combination routine which calls H,
>>>>> H1 and Hx and returns true for halting and false for
>>>>> non-halting.
>>>>>
>>>>> Then show the code for the hat construction derived from this
>>>>> new decider and show how this decider can correctly decide that
>>>>> hat construction.
>>>>>
>>>>
>>>> Before I show any code I have to have my use of static local data
>>>>  validated as acceptable.
>>>
>>> It won't be 'validated' because it simply isn't allowed. As Richard
>>>  has pointed out the mere presence of a static variable doesn't 
>>> necessarily rule out something as a computation if it is simply
>>> there for efficiency's sake, but if the routine actually *depends*
>>> on the use of a static variable so that difference invocations have
>>> access to different information, then you're not dealing with a
>>> computation.
>>>
>>
>> Therefore a TM cannot possibly determine whether or not it is being 
>> infinitely simulated because it is required to make sure that it
>> erases the execution trace that it stored between recursive
>> simulations.
> 
> And? The fact that you really want to be able to do something isn't an 
> argument that that thing is actually doable.
> 
>> This weirdly enough would show that C is strictly more powerful than
>> a TM, thus you and Richard are probably wrong.
> 
> No, it doesn't show this at all.
> 

Sure it does. A C function can determine that it has been called in 
infinitely nested simulating using a static local variable, and TM's 
cannot do this because it is not a proper computation for a TM therefore 
C can do something that a TM cannot making it more powerful that a TM.

> There are no computations which can be done in C which cannot also be 
> done by a Turing Machine. The problem is that you are dealing with 
> something that isn't a computation. 

> We *could* convert this to a 
> computation by supplying your 'execution trace' as a formal input 
> parameter, but then you wouldn't be dealing with the halting problem 
> since that problem defines a halt decider as taking a specific set of 
> inputs which does not include an 'execution trace'.

Been there done that. The problem is that P() can simply empty the 
execution trace every time it is called.

void P(u32 x, u32* execution_trace)
{
   execution_trace[-1] = 0; // empties the execution_trace
   if (H(x, x, execution_trace)))
     HERE: goto HERE;
}


> 
>>>>>>> The whole point of the Linz proof is that for *any* 'halt
>>>>>>> decider' X, one can always construct an X_Hat which it
>>>>>>> cannot decide correctly. Your combined H+H1+Hx+DD is just
>>>>>>> as susceptible to this as any other putative 'halt
>>>>>>> decider'.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> The whole point of all these proofs is that no universal halt
>>>>>>  decider exists. The Olcott combination of H1,H,Hx is such a
>>>>>>  universal halt decider that is purported to not exist.
>>>>>>
>>>>>> The key breakthrough is that Rice's theorem "proved" that no
>>>>>>  decidability decider can possibly exist thus once we have
>>>>>> such a decidability decider Rice's theorem and the halting
>>>>>> theorem both fail.
>>>>>
>>>>> You don't seem to understand what Rice's theorem actually
>>>>> states.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> Historically on comp.theory this has meant that it is impossible
>>>> to create a TM the rejects undecidable inputs.
>>>
>>> What do you mean by an 'undecidable input'? Input to what?
>>>
>>> Rice's theorem says you can't create a TM X which decides some 
>>> nontrivial semantic property of an arbitary Turing Machine Y (or of
>>>  the language accepted by Y). Once you start talking about 'inputs'
>>> you are talking about computations rather than Turing Machines.
>>>
>>> André
>>>
>>
>> H1 decides that H cannot correctly decide the halting status of P.
> 
> Which is neither a property of H nor of P but a statement about the 
> specific computation H(P, P).
> 
> Rice's theorem is concerned with semantic properties of Turing Machines, 
> not of specific computations.
> 
> André
> 

None-the-less the end result is a universal halt decider comprised of 
H1,H,Hx.

-- 
Copyright 2021 Pete Olcott

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

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


#39633

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-09-20 16:52 -0600
Message-ID<sib3bd$gm4$1@dont-email.me>
In reply to#39631
On 2021-09-20 16:29, olcott wrote:

>>> H1 decides that H cannot correctly decide the halting status of P.
>>
>> Which is neither a property of H nor of P but a statement about the 
>> specific computation H(P, P).
>>
>> Rice's theorem is concerned with semantic properties of Turing 
>> Machines, not of specific computations.
>>
>> André
>>
> 
> None-the-less the end result is a universal halt decider comprised of 
> H1,H,Hx.

No, it is not a universal halt decider because the routine which calls 
these three functions to arrive at a halting decision will have its own 
corresponding hat construction which that routine will be unable to decide.

André

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

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


#39636

Fromolcott <NoOne@NoWhere.com>
Date2021-09-20 18:17 -0500
Message-ID<TvCdnZxdb4nji9T8nZ2dnUU7-RednZ2d@giganews.com>
In reply to#39633
On 9/20/2021 5:52 PM, André G. Isaak wrote:
> On 2021-09-20 16:29, olcott wrote:
> 
>>>> H1 decides that H cannot correctly decide the halting status of P.
>>>
>>> Which is neither a property of H nor of P but a statement about the 
>>> specific computation H(P, P).
>>>
>>> Rice's theorem is concerned with semantic properties of Turing 
>>> Machines, not of specific computations.
>>>
>>> André
>>>
>>
>> None-the-less the end result is a universal halt decider comprised of 
>> H1,H,Hx.
> 
> No, it is not a universal halt decider because the routine which calls 
> these three functions to arrive at a halting decision will have its own 
> corresponding hat construction which that routine will be unable to decide.
> 
> André
> 

When the three machines are run separately then a human can look for the 
best two out of three no other machine can thwart this.

-- 
Copyright 2021 Pete Olcott

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

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


#39630

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-20 23:06 +0100
Message-ID<87czp26gw7.fsf@bsb.me.uk>
In reply to#39616
olcott <NoOne@NoWhere.com> writes:

> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx

No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
to Ĥ.qn and you will not detect any difference.  And if H ⟨Ĥ⟩ ⟨Ĥ⟩
transitions to H.qy, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will not terminate and you will
not be able to detect any difference.

Stop pretending to talk about Turing machines.  You don't know enough
about them to avoid silly mistakes like this.  Talk about your secret C
code instead.  The only mistakes anyone can be sure of in that are those
you accidentally reveal.

-- 
Ben.

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


#39632

Fromolcott <NoOne@NoWhere.com>
Date2021-09-20 17:37 -0500
Message-ID<eKudnUlqApyukNT8nZ2dnUU7-KvNnZ2d@giganews.com>
In reply to#39630
On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
> 
> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
> to Ĥ.qn and you will not detect any difference. 

The behavior of Ĥ does not depend on the behavior of H.

A halt decider does not stipulate the behavior of its program under test 
it simply reports the halt status of the behavior of the program under 
test.

The fact that Ĥ was intentionally defined to do the opposite of whatever 
Ĥ.qx reports does not have any effect on H.


>  And if H ⟨Ĥ⟩ ⟨Ĥ⟩
> transitions to H.qy, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will not terminate and you will
> not be able to detect any difference.
> 
> Stop pretending to talk about Turing machines.  You don't know enough
> about them to avoid silly mistakes like this.  Talk about your secret C
> code instead.  The only mistakes anyone can be sure of in that are those
> you accidentally reveal.
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39638

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-20 19:31 -0400
Message-ID<LR82J.78923$z%4.48056@fx37.iad>
In reply to#39632
On 9/20/21 6:37 PM, olcott wrote:
> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>
>> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
>> to Ĥ.qn and you will not detect any difference. 
> 
> The behavior of Ĥ does not depend on the behavior of H.


????

H^ includes a copy of H and that copy is what drives its behavopr.

> 
> A halt decider does not stipulate the behavior of its program under test
> it simply reports the halt status of the behavior of the program under
> test.

Right the instance of H doing the deciding doesn't affect the machine it
is deciding on, but the copy of it that is in the machine surely does.

FAIL.

> 
> The fact that Ĥ was intentionally defined to do the opposite of whatever
> Ĥ.qx reports does not have any effect on H.
> 

Right, the behavior of H^ doesn't affect the behavior of H, which is
sort of the problem. H is SUPPOSED to report on the behavior of H^, so
the fact that it isn't affect by it is the major part of the problem.

H is just WRONG about its prediction of what H^ will do.


> 
>>  And if H ⟨Ĥ⟩ ⟨Ĥ⟩
>> transitions to H.qy, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will not terminate and you will
>> not be able to detect any difference.
>>
>> Stop pretending to talk about Turing machines.  You don't know enough
>> about them to avoid silly mistakes like this.  Talk about your secret C
>> code instead.  The only mistakes anyone can be sure of in that are those
>> you accidentally reveal.
>>
> 
> 

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


#39642

Fromolcott <NoOne@NoWhere.com>
Date2021-09-20 18:48 -0500
Message-ID<1cidnTfzJeJ9gNT8nZ2dnUU7-Y_NnZ2d@giganews.com>
In reply to#39638
On 9/20/2021 6:31 PM, Richard Damon wrote:
> On 9/20/21 6:37 PM, olcott wrote:
>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>>
>>> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
>>> to Ĥ.qn and you will not detect any difference.
>>
>> The behavior of Ĥ does not depend on the behavior of H.
> 
> 
> ????
> 
> H^ includes a copy of H and that copy is what drives its behavopr.

When Ĥ is defined a copy of H is placed at Ĥ.qx and this remains 
separate and distinct from the original H.

> 
>>
>> A halt decider does not stipulate the behavior of its program under test
>> it simply reports the halt status of the behavior of the program under
>> test.
> 
> Right the instance of H doing the deciding doesn't affect the machine it
> is deciding on, but the copy of it that is in the machine surely does.
> 

Yes, the copy does. That is why Linz H gets the right answer and Linz Ĥ 
gets an answer that does not correspond to the behavior of Ĥ.

> FAIL.
> 
>>
>> The fact that Ĥ was intentionally defined to do the opposite of whatever
>> Ĥ.qx reports does not have any effect on H.
>>
> 
> Right, the behavior of H^ doesn't affect the behavior of H, which is
> sort of the problem. H is SUPPOSED to report on the behavior of H^, so
> the fact that it isn't affect by it is the major part of the problem.
> 

The behavior of Ĥ can screw up its own halt status decision yet cannot 
screw up the halt status decision of H.

> H is just WRONG about its prediction of what H^ will do.
> 

Ĥ.qx correctly reports that its input will never halt unless it aborts 
the simulation of its input. When Ĥ does abort the simulation of its 
input that causes Ĥ itself to stop running, not quite the same thing as 
halting.

>>>   And if H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> transitions to H.qy, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will not terminate and you will
>>> not be able to detect any difference.
>>>
>>> Stop pretending to talk about Turing machines.  You don't know enough
>>> about them to avoid silly mistakes like this.  Talk about your secret C
>>> code instead.  The only mistakes anyone can be sure of in that are those
>>> you accidentally reveal.
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

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

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


#39668

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-20 22:38 -0400
Message-ID<XAb2J.17548$dI3.6725@fx10.iad>
In reply to#39642
On 9/20/21 7:48 PM, olcott wrote:
> On 9/20/2021 6:31 PM, Richard Damon wrote:
>> On 9/20/21 6:37 PM, olcott wrote:
>>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>>>
>>>> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will
>>>> transition
>>>> to Ĥ.qn and you will not detect any difference.
>>>
>>> The behavior of Ĥ does not depend on the behavior of H.
>>
>>
>> ????
>>
>> H^ includes a copy of H and that copy is what drives its behavopr.
> 
> When Ĥ is defined a copy of H is placed at Ĥ.qx and this remains
> separate and distinct from the original H.

It is the IDENTICAL COMPUTATION, and as such MUST behave the same.

BASIC DEFINITION.

> 
>>
>>>
>>> A halt decider does not stipulate the behavior of its program under test
>>> it simply reports the halt status of the behavior of the program under
>>> test.
>>
>> Right the instance of H doing the deciding doesn't affect the machine it
>> is deciding on, but the copy of it that is in the machine surely does.
>>
> 
> Yes, the copy does. That is why Linz H gets the right answer and Linz Ĥ
> gets an answer that does not correspond to the behavior of Ĥ.

Linz H^ never gives 'an answer', it has behavior. Linz H^ isn't a
'decider' to give an answer, it USES a decider, a copy of H, that MUST
behave exactly like all other copies of H given the same input.

The fact that is seems it doesn't says that your H isn't a Computation,
and thus can't be a Decider.

> 
>> FAIL.
>>
>>>
>>> The fact that Ĥ was intentionally defined to do the opposite of whatever
>>> Ĥ.qx reports does not have any effect on H.
>>>
>>
>> Right, the behavior of H^ doesn't affect the behavior of H, which is
>> sort of the problem. H is SUPPOSED to report on the behavior of H^, so
>> the fact that it isn't affect by it is the major part of the problem.
>>
> 
> The behavior of Ĥ can screw up its own halt status decision yet cannot
> screw up the halt status decision of H.

IF the H inside H^ gives a different result then the H outside, H is
broken and FOREVER disqualified to be a decider. PERIOD. RED CARD.

The H outside has the Job or predicting what H^ will do.

> 
>> H is just WRONG about its prediction of what H^ will do.
>>
> 
> Ĥ.qx correctly reports that its input will never halt unless it aborts
> the simulation of its input. When Ĥ does abort the simulation of its
> input that causes Ĥ itself to stop running, not quite the same thing as
> halting.

Wrong Question even. H is supposed to answer if the machine given as its
input will halt in finite time FOR ANY REASON. It doesn't matter that
the copy of H inside has aborted it simulation of a copy of that
machine. H^/P Halts, so the right answer is Halting.

Yes, the fact that H never simulates to the halting state doesn't by
itself prove that the machine represented by the input would halt, but
neither does it prove that it doesn't. When we actually RUN that machine
on its own. you agree it halts, so therefore, assuming that H is a
computation and thus H^/P is, this proves that the machie given to H
would also halt.

The concept of what some other H does it totally irrelevant, as H IS
WHAT IT IS, and any other H is a DIFFERENT decider giving a DIFFERENT
machine it needs to decide on.

Choose your error.

a) H is wrong.
b) H is disqualified for not being a Computation.

In my opinion, it is likely BOTH.


> 
>>>>   And if H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> transitions to H.qy, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will not terminate and you will
>>>> not be able to detect any difference.
>>>>
>>>> Stop pretending to talk about Turing machines.  You don't know enough
>>>> about them to avoid silly mistakes like this.  Talk about your secret C
>>>> code instead.  The only mistakes anyone can be sure of in that are
>>>> those
>>>> you accidentally reveal.
>>>>
>>>
>>>
>>
> 
> 

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


#39669

Fromolcott <NoOne@NoWhere.com>
Date2021-09-20 21:45 -0500
Message-ID<OLidnbGeP-Co2tT8nZ2dnUU7-IPNnZ2d@giganews.com>
In reply to#39668
On 9/20/2021 9:38 PM, Richard Damon wrote:
> On 9/20/21 7:48 PM, olcott wrote:
>> On 9/20/2021 6:31 PM, Richard Damon wrote:
>>> On 9/20/21 6:37 PM, olcott wrote:
>>>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>>>>
>>>>> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will
>>>>> transition
>>>>> to Ĥ.qn and you will not detect any difference.
>>>>
>>>> The behavior of Ĥ does not depend on the behavior of H.
>>>
>>>
>>> ????
>>>
>>> H^ includes a copy of H and that copy is what drives its behavopr.
>>
>> When Ĥ is defined a copy of H is placed at Ĥ.qx and this remains
>> separate and distinct from the original H.
> 
> It is the IDENTICAL COMPUTATION, and as such MUST behave the same.

It has identical code yet the computation is not identical and this is 
easy to see in the H1/H/P code because the execution trace is not the 
same. When we can only imagine what H and Ĥ does then we are free to 
assume that they behave in exactly the same way and are not contradicted 
by any execution trace proving otherwise.

-- 
Copyright 2021 Pete Olcott

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

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


#39678

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-20 23:27 -0400
Message-ID<Wic2J.33830$tA2.2037@fx02.iad>
In reply to#39669
On 9/20/21 10:45 PM, olcott wrote:
> On 9/20/2021 9:38 PM, Richard Damon wrote:
>> On 9/20/21 7:48 PM, olcott wrote:
>>> On 9/20/2021 6:31 PM, Richard Damon wrote:
>>>> On 9/20/21 6:37 PM, olcott wrote:
>>>>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know
>>>>>>> that
>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>>>>>
>>>>>> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will
>>>>>> transition
>>>>>> to Ĥ.qn and you will not detect any difference.
>>>>>
>>>>> The behavior of Ĥ does not depend on the behavior of H.
>>>>
>>>>
>>>> ????
>>>>
>>>> H^ includes a copy of H and that copy is what drives its behavopr.
>>>
>>> When Ĥ is defined a copy of H is placed at Ĥ.qx and this remains
>>> separate and distinct from the original H.
>>
>> It is the IDENTICAL COMPUTATION, and as such MUST behave the same.
> 
> It has identical code yet the computation is not identical and this is
> easy to see in the H1/H/P code because the execution trace is not the
> same. When we can only imagine what H and Ĥ does then we are free to
> assume that they behave in exactly the same way and are not contradicted
> by any execution trace proving otherwise.
> 

And, as I said that means either the code ISN'T identical, or the code
is using a hidden input, like the program counter is running at.

PERIOD.

They CAN'T be the equivalents of the same Turing Machine, and since the
proof is ACTUALLY about Turing Machine, you have effectively PROVED that
one of your stated premises is FALSE.

Something isn't the equivalent of the Turing Machine it is claimed to be
the equivalent of.

FAIL.

All you have done is proved that non-computations playing to be
computation can give weird results.

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


#39685

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-09-20 23:14 -0700
Message-ID<9358b6eb-642e-4c24-b804-1d7950766145n@googlegroups.com>
In reply to#39669
On Tuesday, 21 September 2021 at 03:45:16 UTC+1, olcott wrote:
> On 9/20/2021 9:38 PM, Richard Damon wrote: 
> > On 9/20/21 7:48 PM, olcott wrote: 
> >> On 9/20/2021 6:31 PM, Richard Damon wrote: 
> >>> On 9/20/21 6:37 PM, olcott wrote: 
> >>>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote: 
> >>>>> olcott <No...@NoWhere.com> writes: 
> >>>>> 
> >>>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that 
> >>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx 
> >>>>> 
> >>>>> No. If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will 
> >>>>> transition 
> >>>>> to Ĥ.qn and you will not detect any difference. 
> >>>> 
> >>>> The behavior of Ĥ does not depend on the behavior of H. 
> >>> 
> >>> 
> >>> ???? 
> >>> 
> >>> H^ includes a copy of H and that copy is what drives its behavopr. 
> >> 
> >> When Ĥ is defined a copy of H is placed at Ĥ.qx and this remains 
> >> separate and distinct from the original H. 
> > 
> > It is the IDENTICAL COMPUTATION, and as such MUST behave the same.
> It has identical code yet the computation is not identical and this is 
> easy to see in the H1/H/P code because the execution trace is not the 
> same. When we can only imagine what H and Ĥ does then we are free to 
> assume that they behave in exactly the same way and are not contradicted 
> by any execution trace proving otherwise.
>
If you use a static local variable in a C function, then one common reason is that
it acts as a hidden input to the function. So two calls with identical arguments
can return different results. 
It's also possible, by abusing the C language, to write C code such that two
functions have identical source code but different behaviour. For instance you
could take the address of a local variable and use it to calculate a return value.

These things aren't of much interest to theoretical computer science, they 
are programming details, and rather hacky ones at that. But they do mean that
you can create something which looks like a contradiction to an accepted result
in computer science, because of the confusion between C "functions" and
mathematical functions.

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


#39688

Fromolcott <NoOne@NoWhere.com>
Date2021-09-21 09:39 -0500
Message-ID<nuudnXgZMrcBc9T8nZ2dnUU7-L_NnZ2d@giganews.com>
In reply to#39685
On 9/21/2021 1:14 AM, Malcolm McLean wrote:
> On Tuesday, 21 September 2021 at 03:45:16 UTC+1, olcott wrote:
>> On 9/20/2021 9:38 PM, Richard Damon wrote:
>>> On 9/20/21 7:48 PM, olcott wrote:
>>>> On 9/20/2021 6:31 PM, Richard Damon wrote:
>>>>> On 9/20/21 6:37 PM, olcott wrote:
>>>>>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>
>>>>>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>>>>>>
>>>>>>> No. If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will
>>>>>>> transition
>>>>>>> to Ĥ.qn and you will not detect any difference.
>>>>>>
>>>>>> The behavior of Ĥ does not depend on the behavior of H.
>>>>>
>>>>>
>>>>> ????
>>>>>
>>>>> H^ includes a copy of H and that copy is what drives its behavopr.
>>>>
>>>> When Ĥ is defined a copy of H is placed at Ĥ.qx and this remains
>>>> separate and distinct from the original H.
>>>
>>> It is the IDENTICAL COMPUTATION, and as such MUST behave the same.
>> It has identical code yet the computation is not identical and this is
>> easy to see in the H1/H/P code because the execution trace is not the
>> same. When we can only imagine what H and Ĥ does then we are free to
>> assume that they behave in exactly the same way and are not contradicted
>> by any execution trace proving otherwise.
>>
> If you use a static local variable in a C function, then one common reason is that
> it acts as a hidden input to the function. So two calls with identical arguments
> can return different results.
> It's also possible, by abusing the C language, to write C code such that two
> functions have identical source code but different behaviour. For instance you
> could take the address of a local variable and use it to calculate a return value.
> 
> These things aren't of much interest to theoretical computer science, they
> are programming details, and rather hacky ones at that. But they do mean that
> you can create something which looks like a contradiction to an accepted result
> in computer science, because of the confusion between C "functions" and
> mathematical functions.
> 

The bottom line is that a TM must use the equivalent of static local 
data to be able to keep track that it is stuck in infinitely nested 
simulation:

the simulation of the

machine description of a UTM H that simulates
the machine description P the simulates

machine description of a UTM H that simulates
the machine description P the simulates

machine description of a UTM H that simulates
the machine description P the simulates ...

Olcott H can detect when Olcott P is doing this only when Olcott H is 
able to use static local data, otherwise Olcott H has its memory of 
prior invocations erased upon every subsequent simulation.

It seems ridiculous that this level of functionality is simply 
disallowed. If it is simply disallowed then that makes my H strictly 
more powerful than the Linz TM H can be.

-- 
Copyright 2021 Pete Olcott

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

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


#39698

FromRichard Damon <Richard@Damon-Family.org>
Date2021-09-21 19:16 -0400
Message-ID<JJt2J.67305$VZ1.38597@fx08.iad>
In reply to#39688
On 9/21/21 10:39 AM, olcott wrote:
> On 9/21/2021 1:14 AM, Malcolm McLean wrote:
>> On Tuesday, 21 September 2021 at 03:45:16 UTC+1, olcott wrote:
>>> On 9/20/2021 9:38 PM, Richard Damon wrote:
>>>> On 9/20/21 7:48 PM, olcott wrote:
>>>>> On 9/20/2021 6:31 PM, Richard Damon wrote:
>>>>>> On 9/20/21 6:37 PM, olcott wrote:
>>>>>>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we
>>>>>>>>> know that
>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>>>>>>>
>>>>>>>> No. If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will
>>>>>>>> transition
>>>>>>>> to Ĥ.qn and you will not detect any difference.
>>>>>>>
>>>>>>> The behavior of Ĥ does not depend on the behavior of H.
>>>>>>
>>>>>>
>>>>>> ????
>>>>>>
>>>>>> H^ includes a copy of H and that copy is what drives its behavopr.
>>>>>
>>>>> When Ĥ is defined a copy of H is placed at Ĥ.qx and this remains
>>>>> separate and distinct from the original H.
>>>>
>>>> It is the IDENTICAL COMPUTATION, and as such MUST behave the same.
>>> It has identical code yet the computation is not identical and this is
>>> easy to see in the H1/H/P code because the execution trace is not the
>>> same. When we can only imagine what H and Ĥ does then we are free to
>>> assume that they behave in exactly the same way and are not contradicted
>>> by any execution trace proving otherwise.
>>>
>> If you use a static local variable in a C function, then one common
>> reason is that
>> it acts as a hidden input to the function. So two calls with identical
>> arguments
>> can return different results.
>> It's also possible, by abusing the C language, to write C code such
>> that two
>> functions have identical source code but different behaviour. For
>> instance you
>> could take the address of a local variable and use it to calculate a
>> return value.
>>
>> These things aren't of much interest to theoretical computer science,
>> they
>> are programming details, and rather hacky ones at that. But they do
>> mean that
>> you can create something which looks like a contradiction to an
>> accepted result
>> in computer science, because of the confusion between C "functions" and
>> mathematical functions.
>>
> 
> The bottom line is that a TM must use the equivalent of static local
> data to be able to keep track that it is stuck in infinitely nested
> simulation:

Or just not be able to.

> 
> the simulation of the
> 
> machine description of a UTM H that simulates
> the machine description P the simulates
> 
> machine description of a UTM H that simulates
> the machine description P the simulates
> 
> machine description of a UTM H that simulates
> the machine description P the simulates ...
> 
> Olcott H can detect when Olcott P is doing this only when Olcott H is
> able to use static local data, otherwise Olcott H has its memory of
> prior invocations erased upon every subsequent simulation.
> 
> It seems ridiculous that this level of functionality is simply
> disallowed. If it is simply disallowed then that makes my H strictly
> more powerful than the Linz TM H can be.
> 

If you H isn't a computatation, then it doesn't actually prove anything.

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


#39646

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-21 01:45 +0100
Message-ID<87v92u4uzx.fsf@bsb.me.uk>
In reply to#39632
olcott <NoOne@NoWhere.com> writes:

> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
>> to Ĥ.qn and you will not detect any difference. 
>
> The behavior of Ĥ does not depend on the behavior of H.

Peek nonsense.

-- 
Ben.

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


#39648

Fromolcott <NoOne@NoWhere.com>
Date2021-09-20 19:53 -0500
Message-ID<262dnR9YQsyGsNT8nZ2dnUU7-Y9QAAAA@giganews.com>
In reply to#39646
On 9/20/2021 7:45 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
>>> to Ĥ.qn and you will not detect any difference.
>>
>> The behavior of Ĥ does not depend on the behavior of H.
> 
> Peek nonsense.
> 

 >>> If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition

You have the cause-and-effect backwards.



-- 
Copyright 2021 Pete Olcott

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

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


#39653

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-09-21 02:39 +0100
Message-ID<87k0ja4sh7.fsf@bsb.me.uk>
In reply to#39648
olcott <NoOne@NoWhere.com> writes:

> On 9/20/2021 7:45 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>>> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
>>>> to Ĥ.qn and you will not detect any difference.
>>>
>>> The behavior of Ĥ does not depend on the behavior of H.
>> Peek nonsense.
>
>>>> If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
>
> You have the cause-and-effect backwards.

No.  There is no cause and effect, but there is a mutual dependency.  H^
is derived from H, and given H^ once could derive H.  It is not possible
to have and H/H^ pair that does nor behave as I described.

-- 
Ben.

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


#39654

Fromolcott <NoOne@NoWhere.com>
Date2021-09-20 20:44 -0500
Message-ID<TrydnSDukYlrpdT8nZ2dnUU7-UWdnZ2d@giganews.com>
In reply to#39653
On 9/20/2021 8:39 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 9/20/2021 7:45 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx
>>>>> No.  If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
>>>>> to Ĥ.qn and you will not detect any difference.
>>>>
>>>> The behavior of Ĥ does not depend on the behavior of H.
>>> Peek nonsense.
>>
>>>>> If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn, then Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ will transition
>>
>> You have the cause-and-effect backwards.
> 
> No.  There is no cause and effect, but there is a mutual dependency.  H^
> is derived from H, and given H^ once could derive H.  It is not possible
> to have and H/H^ pair that does nor behave as I described.
> 

No. Ĥ has an unnamed copy of H placed at its Ĥ.qx state.


-- 
Copyright 2021 Pete Olcott

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

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


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

Back to top | Article view | comp.theory


csiph-web