On 2021-09-19 08:34, olcott wrote:
> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>> On 2021-09-18 22:10, André G. Isaak wrote:
>>
>>> And note that Rice is talking about properties of Turing Machines
>>> (or, more properly, of the language accepted by a TM), not computations.
>>
>> I realized immediately after hitting 'send' that the above will no
>> doubt confuse you since people have been telling you that Turing
>> Machines can only express computations whereas C/x86 aren't thus
>> constrained.
>>
>> A computation is a Turing Machine description PLUS an input string.
>>
>> Rice's theorem is concerned with the Turing Machine's themselves.
>>
>> The Linz proof shows that you cannot construct a halting decider, i.e.
>> a decider which correctly determines for any given TM + input string
>> pair, whether that pair represents a halting computation.
>>
>> Rice's theorem, on the other hand, would rule out the construction of
>> something like a Decider Decider, i.e. a TM which takes as its input a
>> TM description and determines whether that TM qualifies as a decider,
>> i.e. is guaranteed to halt on *any* possible input.
>>
>> André
>>
>
> Here is where I referred to my code defining a
> a decidability decider nine days before you did:

Where did I define or even mention a 'decidability decider'? Above I
discussed (but did not define) a DECIDER decider, i.e. a TM which
determines whether another TM qualifies as a decider.

> On 9/9/2021 10:25 AM, olcott wrote:
> > It is the case that H(P,P)==0 is correct
> > It is the case that H1((P,P)==1 is correct
> > It is the case the this is inconsistent.
> > It is the case that this inconsistency
>
> > defines a decidability decider that correctly
> > defines a decidability decider that correctly
> > defines a decidability decider that correctly
>
> > rejects P on the basis that P has the
> > pathological self-reference(Olcott 2004) error.

So what exactly is it that the above is deciding? And how does this
relate to Rice? If you want to claim this is somehow related to rice,
you need to identify some semantic property that you claim to be able to
decide.

André

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

On 9/19/2021 10:40 AM, André G. Isaak wrote:
> On 2021-09-19 08:34, olcott wrote:
>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>
>>>> And note that Rice is talking about properties of Turing Machines
>>>> (or, more properly, of the language accepted by a TM), not
>>>> computations.
>>>
>>> I realized immediately after hitting 'send' that the above will no
>>> doubt confuse you since people have been telling you that Turing
>>> Machines can only express computations whereas C/x86 aren't thus
>>> constrained.
>>>
>>> A computation is a Turing Machine description PLUS an input string.
>>>
>>> Rice's theorem is concerned with the Turing Machine's themselves.
>>>
>>> The Linz proof shows that you cannot construct a halting decider,
>>> i.e. a decider which correctly determines for any given TM + input
>>> string pair, whether that pair represents a halting computation.
>>>
>>> Rice's theorem, on the other hand, would rule out the construction of
>>> something like a Decider Decider, i.e. a TM which takes as its input
>>> a TM description and determines whether that TM qualifies as a
>>> decider, i.e. is guaranteed to halt on *any* possible input.
>>>
>>> André
>>>
>>
>> Here is where I referred to my code defining a
>> a decidability decider nine days before you did:
>
> Where did I define or even mention a 'decidability decider'? Above I
> discussed (but did not define) a DECIDER decider, i.e. a TM which
> determines whether another TM qualifies as a decider.
>
>> On 9/9/2021 10:25 AM, olcott wrote:
>>  > It is the case that H(P,P)==0 is correct
>>  > It is the case that H1((P,P)==1 is correct
>>  > It is the case the this is inconsistent.
>>  > It is the case that this inconsistency
>>
>>  > defines a decidability decider that correctly
>>  > defines a decidability decider that correctly
>>  > defines a decidability decider that correctly
>>
>>  > rejects P on the basis that P has the
>>  > pathological self-reference(Olcott 2004) error.
>
> So what exactly is it that the above is deciding? And how does this
> relate to Rice? If you want to claim this is somehow related to rice,
> you need to identify some semantic property that you claim to be able to
> decide.
>
> André
>

It is deciding that either H/P or H1/P form the pathological
self-reference error(Olcott 2004). As I said in 2004 this is the same
error as the Liar Paradox. This means that either H/P or H1/P are not
correctly decidable.

--
Copyright 2021 Pete Olcott

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

On 2021-09-19 09:46, olcott wrote:
> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>> On 2021-09-19 08:34, olcott wrote:
>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>
>>>>> And note that Rice is talking about properties of Turing Machines
>>>>> (or, more properly, of the language accepted by a TM), not
>>>>> computations.
>>>>
>>>> I realized immediately after hitting 'send' that the above will no
>>>> doubt confuse you since people have been telling you that Turing
>>>> Machines can only express computations whereas C/x86 aren't thus
>>>> constrained.
>>>>
>>>> A computation is a Turing Machine description PLUS an input string.
>>>>
>>>> Rice's theorem is concerned with the Turing Machine's themselves.
>>>>
>>>> The Linz proof shows that you cannot construct a halting decider,
>>>> i.e. a decider which correctly determines for any given TM + input
>>>> string pair, whether that pair represents a halting computation.
>>>>
>>>> Rice's theorem, on the other hand, would rule out the construction
>>>> of something like a Decider Decider, i.e. a TM which takes as its
>>>> input a TM description and determines whether that TM qualifies as a
>>>> decider, i.e. is guaranteed to halt on *any* possible input.
>>>>
>>>> André
>>>>
>>>
>>> Here is where I referred to my code defining a
>>> a decidability decider nine days before you did:
>>
>> Where did I define or even mention a 'decidability decider'? Above I
>> discussed (but did not define) a DECIDER decider, i.e. a TM which
>> determines whether another TM qualifies as a decider.
>>
>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>  > It is the case that H(P,P)==0 is correct
>>>  > It is the case that H1((P,P)==1 is correct
>>>  > It is the case the this is inconsistent.
>>>  > It is the case that this inconsistency
>>>
>>>  > defines a decidability decider that correctly
>>>  > defines a decidability decider that correctly
>>>  > defines a decidability decider that correctly
>>>
>>>  > rejects P on the basis that P has the
>>>  > pathological self-reference(Olcott 2004) error.
>>
>> So what exactly is it that the above is deciding? And how does this
>> relate to Rice? If you want to claim this is somehow related to rice,
>> you need to identify some semantic property that you claim to be able
>> to decide.
>>
>> André
>>
>
> It is deciding that either H/P or H1/P form the pathological
> self-reference error(Olcott 2004). As I said in 2004 this is the same
> error as the Liar Paradox. This means that either H/P or H1/P are not
> correctly decidable.

The post in which I mentioned a 'decider decider' which you somehow
misread as 'decidability decider' was intended to clarify a single
sentence from an earlier post which you entirely ignored. Why don't you
go back and actually read that earlier post and address the points made
therein.

Your ill-defined notion of a 'pathological self-reference error' doesn't
appear to be a property of a Turing Machine, which is what Rice's
theorem is concerned with. To the extent that it is a property at all,
it appears to be a property of specific computations, so this has
absolutely no relevance to Rice.

André

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

On 9/19/2021 11:11 AM, André G. Isaak wrote:
> On 2021-09-19 09:46, olcott wrote:
>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>> On 2021-09-19 08:34, olcott wrote:
>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>
>>>>>> And note that Rice is talking about properties of Turing Machines
>>>>>> (or, more properly, of the language accepted by a TM), not
>>>>>> computations.
>>>>>
>>>>> I realized immediately after hitting 'send' that the above will no
>>>>> doubt confuse you since people have been telling you that Turing
>>>>> Machines can only express computations whereas C/x86 aren't thus
>>>>> constrained.
>>>>>
>>>>> A computation is a Turing Machine description PLUS an input string.
>>>>>
>>>>> Rice's theorem is concerned with the Turing Machine's themselves.
>>>>>
>>>>> The Linz proof shows that you cannot construct a halting decider,
>>>>> i.e. a decider which correctly determines for any given TM + input
>>>>> string pair, whether that pair represents a halting computation.
>>>>>
>>>>> Rice's theorem, on the other hand, would rule out the construction
>>>>> of something like a Decider Decider, i.e. a TM which takes as its
>>>>> input a TM description and determines whether that TM qualifies as
>>>>> a decider, i.e. is guaranteed to halt on *any* possible input.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> Here is where I referred to my code defining a
>>>> a decidability decider nine days before you did:
>>>
>>> Where did I define or even mention a 'decidability decider'? Above I
>>> discussed (but did not define) a DECIDER decider, i.e. a TM which
>>> determines whether another TM qualifies as a decider.
>>>
>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>  > It is the case that H(P,P)==0 is correct
>>>>  > It is the case that H1((P,P)==1 is correct
>>>>  > It is the case the this is inconsistent.
>>>>  > It is the case that this inconsistency
>>>>
>>>>  > defines a decidability decider that correctly
>>>>  > defines a decidability decider that correctly
>>>>  > defines a decidability decider that correctly
>>>>
>>>>  > rejects P on the basis that P has the
>>>>  > pathological self-reference(Olcott 2004) error.
>>>
>>> So what exactly is it that the above is deciding? And how does this
>>> relate to Rice? If you want to claim this is somehow related to rice,
>>> you need to identify some semantic property that you claim to be able
>>> to decide.
>>>
>>> André
>>>
>>
>> It is deciding that either H/P or H1/P form the pathological
>> self-reference error(Olcott 2004). As I said in 2004 this is the same
>> error as the Liar Paradox. This means that either H/P or H1/P are not
>> correctly decidable.
>
> The post in which I mentioned a 'decider decider' which you somehow
> misread as 'decidability decider' was intended to clarify a single
> sentence from an earlier post which you entirely ignored. Why don't you
> go back and actually read that earlier post and address the points made
> therein.
>
> Your ill-defined notion of a 'pathological self-reference error' doesn't
> appear to be a property of a Turing Machine, which is what Rice's
> theorem is concerned with. To the extent that it is a property at all,
> it appears to be a property of specific computations, so this has
> absolutely no relevance to Rice.
>
> André
>

It is the property of H(P,P).

u32 PSR_Olcott_2004(u32 P)
{ return H1(P,P) != H(P,P);
}

Decides that H(P,P) cannot correctly decide the halt status of its
input, thus a semantic property of H relative to P.

The Liar Paradox works this same way.
"This sentence is not true."
When it refers to itself it has the pathological self-reference
error(Olcott 2004).

This is the same as H(P,P) where the input to H refers to H.

When we transform the Liar Paradox so that it does not refer to itself

This sentence is not true: "2 + 3 = 7" then the pathological
self-reference error(Olcott 2004) is eliminated.

The same thing occurs with H1(P,P).

--
Copyright 2021 Pete Olcott

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

On 2021-09-19 10:39, olcott wrote:
> On 9/19/2021 11:11 AM, André G. Isaak wrote:
>> On 2021-09-19 09:46, olcott wrote:
>>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>>> On 2021-09-19 08:34, olcott wrote:
>>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>>
>>>>>>> And note that Rice is talking about properties of Turing Machines
>>>>>>> (or, more properly, of the language accepted by a TM), not
>>>>>>> computations.
>>>>>>
>>>>>> I realized immediately after hitting 'send' that the above will no
>>>>>> doubt confuse you since people have been telling you that Turing
>>>>>> Machines can only express computations whereas C/x86 aren't thus
>>>>>> constrained.
>>>>>>
>>>>>> A computation is a Turing Machine description PLUS an input string.
>>>>>>
>>>>>> Rice's theorem is concerned with the Turing Machine's themselves.
>>>>>>
>>>>>> The Linz proof shows that you cannot construct a halting decider,
>>>>>> i.e. a decider which correctly determines for any given TM + input
>>>>>> string pair, whether that pair represents a halting computation.
>>>>>>
>>>>>> Rice's theorem, on the other hand, would rule out the construction
>>>>>> of something like a Decider Decider, i.e. a TM which takes as its
>>>>>> input a TM description and determines whether that TM qualifies as
>>>>>> a decider, i.e. is guaranteed to halt on *any* possible input.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> Here is where I referred to my code defining a
>>>>> a decidability decider nine days before you did:
>>>>
>>>> Where did I define or even mention a 'decidability decider'? Above I
>>>> discussed (but did not define) a DECIDER decider, i.e. a TM which
>>>> determines whether another TM qualifies as a decider.
>>>>
>>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>>  > It is the case that H(P,P)==0 is correct
>>>>>  > It is the case that H1((P,P)==1 is correct
>>>>>  > It is the case the this is inconsistent.
>>>>>  > It is the case that this inconsistency
>>>>>
>>>>>  > defines a decidability decider that correctly
>>>>>  > defines a decidability decider that correctly
>>>>>  > defines a decidability decider that correctly
>>>>>
>>>>>  > rejects P on the basis that P has the
>>>>>  > pathological self-reference(Olcott 2004) error.
>>>>
>>>> So what exactly is it that the above is deciding? And how does this
>>>> relate to Rice? If you want to claim this is somehow related to
>>>> rice, you need to identify some semantic property that you claim to
>>>> be able to decide.
>>>>
>>>> André
>>>>
>>>
>>> It is deciding that either H/P or H1/P form the pathological
>>> self-reference error(Olcott 2004). As I said in 2004 this is the same
>>> error as the Liar Paradox. This means that either H/P or H1/P are not
>>> correctly decidable.
>>
>> The post in which I mentioned a 'decider decider' which you somehow
>> misread as 'decidability decider' was intended to clarify a single
>> sentence from an earlier post which you entirely ignored. Why don't
>> you go back and actually read that earlier post and address the points
>> made therein.
>>
>> Your ill-defined notion of a 'pathological self-reference error'
>> doesn't appear to be a property of a Turing Machine, which is what
>> Rice's theorem is concerned with. To the extent that it is a property
>> at all, it appears to be a property of specific computations, so this
>> has absolutely no relevance to Rice.
>>
>> André
>>
>
> It is the property of H(P,P).

Right, which means this is entirely irrelevant to Rice's theorem.

> u32 PSR_Olcott_2004(u32 P)
> {
>   return H1(P,P) != H(P,P);
> }
>
> Decides that H(P,P) cannot correctly decide the halt status of its
> input,

No, it does not. It decides that the results of H1(P, P) doesn't match
the results of H(P, P). It 'decides' that one of these is correct and
the other is not but it cannot tell you which one, which means it can't
decide whether H(P, P) can correctly decide the halt status of its input.

> thus a semantic property of H relative to P.

That's not a property (semantic or otherwise) of *either* P or H.

> The Liar Paradox works this same way.

The liar's paradox is completely irrelevant to Linz.

André

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

On 9/19/2021 11:56 AM, André G. Isaak wrote:
> On 2021-09-19 10:39, olcott wrote:
>> On 9/19/2021 11:11 AM, André G. Isaak wrote:
>>> On 2021-09-19 09:46, olcott wrote:
>>>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>>>> On 2021-09-19 08:34, olcott wrote:
>>>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>>>
>>>>>>>> And note that Rice is talking about properties of Turing
>>>>>>>> Machines (or, more properly, of the language accepted by a TM),
>>>>>>>> not computations.
>>>>>>>
>>>>>>> I realized immediately after hitting 'send' that the above will
>>>>>>> no doubt confuse you since people have been telling you that
>>>>>>> Turing Machines can only express computations whereas C/x86
>>>>>>> aren't thus constrained.
>>>>>>>
>>>>>>> A computation is a Turing Machine description PLUS an input string.
>>>>>>>
>>>>>>> Rice's theorem is concerned with the Turing Machine's themselves.
>>>>>>>
>>>>>>> The Linz proof shows that you cannot construct a halting decider,
>>>>>>> i.e. a decider which correctly determines for any given TM +
>>>>>>> input string pair, whether that pair represents a halting
>>>>>>> computation.
>>>>>>>
>>>>>>> Rice's theorem, on the other hand, would rule out the
>>>>>>> construction of something like a Decider Decider, i.e. a TM which
>>>>>>> takes as its input a TM description and determines whether that
>>>>>>> TM qualifies as a decider, i.e. is guaranteed to halt on *any*
>>>>>>> possible input.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> Here is where I referred to my code defining a
>>>>>> a decidability decider nine days before you did:
>>>>>
>>>>> Where did I define or even mention a 'decidability decider'? Above
>>>>> I discussed (but did not define) a DECIDER decider, i.e. a TM which
>>>>> determines whether another TM qualifies as a decider.
>>>>>
>>>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>>>  > It is the case that H(P,P)==0 is correct
>>>>>>  > It is the case that H1((P,P)==1 is correct
>>>>>>  > It is the case the this is inconsistent.
>>>>>>  > It is the case that this inconsistency
>>>>>>
>>>>>>  > defines a decidability decider that correctly
>>>>>>  > defines a decidability decider that correctly
>>>>>>  > defines a decidability decider that correctly
>>>>>>
>>>>>>  > rejects P on the basis that P has the
>>>>>>  > pathological self-reference(Olcott 2004) error.
>>>>>
>>>>> So what exactly is it that the above is deciding? And how does this
>>>>> relate to Rice? If you want to claim this is somehow related to
>>>>> rice, you need to identify some semantic property that you claim to
>>>>> be able to decide.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> It is deciding that either H/P or H1/P form the pathological
>>>> self-reference error(Olcott 2004). As I said in 2004 this is the
>>>> same error as the Liar Paradox. This means that either H/P or H1/P
>>>> are not correctly decidable.
>>>
>>> The post in which I mentioned a 'decider decider' which you somehow
>>> misread as 'decidability decider' was intended to clarify a single
>>> sentence from an earlier post which you entirely ignored. Why don't
>>> you go back and actually read that earlier post and address the
>>> points made therein.
>>>
>>> Your ill-defined notion of a 'pathological self-reference error'
>>> doesn't appear to be a property of a Turing Machine, which is what
>>> Rice's theorem is concerned with. To the extent that it is a property
>>> at all, it appears to be a property of specific computations, so this
>>> has absolutely no relevance to Rice.
>>>
>>> André
>>>
>>
>> It is the property of H(P,P).
>
> Right, which means this is entirely irrelevant to Rice's theorem.
>

Many historical posts in comp.theory say otherwise.
If a function can be provided that correctly decides that a specific TM
cannot correctly decide a specific input pair (according to many
historical posts on comp.theory) this does refute Rice's theorem.

>> u32 PSR_Olcott_2004(u32 P)
>> {
>>    return H1(P,P) != H(P,P);
>> }
>>
>> Decides that H(P,P) cannot correctly decide the halt status of its input,
>
>
> No, it does not. It decides that the results of H1(P, P) doesn't match
> the results of H(P, P). It 'decides' that one of these is correct and
> the other is not but it cannot tell you which one, which means it can't
> decide whether H(P, P) can correctly decide the halt status of its input.
>

I simply have not gotten to that part yet.

>> thus a semantic property of H relative to P.
>
> That's not a property (semantic or otherwise) of *either* P or H.
>
>> The Liar Paradox works this same way.
>
> The liar's paradox is completely irrelevant to Linz.
>
> André
>

The pathological self-reference error (Olcott 2004) is specifically
relevant to:
(a) The Halting Theorem
(b) The 1931 Incompleteness Theorem
(c) The Tarski undefinability theorem
(d) The Liar Paradox (upon which (c) is based).

--
Copyright 2021 Pete Olcott

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

On 2021-09-19 11:07, olcott wrote:
> On 9/19/2021 11:56 AM, André G. Isaak wrote:
>> On 2021-09-19 10:39, olcott wrote:
>>> On 9/19/2021 11:11 AM, André G. Isaak wrote:
>>>> On 2021-09-19 09:46, olcott wrote:
>>>>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>>>>> On 2021-09-19 08:34, olcott wrote:
>>>>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>>>>
>>>>>>>>> And note that Rice is talking about properties of Turing
>>>>>>>>> Machines (or, more properly, of the language accepted by a TM),
>>>>>>>>> not computations.
>>>>>>>>
>>>>>>>> I realized immediately after hitting 'send' that the above will
>>>>>>>> no doubt confuse you since people have been telling you that
>>>>>>>> Turing Machines can only express computations whereas C/x86
>>>>>>>> aren't thus constrained.
>>>>>>>>
>>>>>>>> A computation is a Turing Machine description PLUS an input string.
>>>>>>>>
>>>>>>>> Rice's theorem is concerned with the Turing Machine's themselves.
>>>>>>>>
>>>>>>>> The Linz proof shows that you cannot construct a halting
>>>>>>>> decider, i.e. a decider which correctly determines for any given
>>>>>>>> TM + input string pair, whether that pair represents a halting
>>>>>>>> computation.
>>>>>>>>
>>>>>>>> Rice's theorem, on the other hand, would rule out the
>>>>>>>> construction of something like a Decider Decider, i.e. a TM
>>>>>>>> which takes as its input a TM description and determines whether
>>>>>>>> that TM qualifies as a decider, i.e. is guaranteed to halt on
>>>>>>>> *any* possible input.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> Here is where I referred to my code defining a
>>>>>>> a decidability decider nine days before you did:
>>>>>>
>>>>>> Where did I define or even mention a 'decidability decider'? Above
>>>>>> I discussed (but did not define) a DECIDER decider, i.e. a TM
>>>>>> which determines whether another TM qualifies as a decider.
>>>>>>
>>>>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>>>>  > It is the case that H(P,P)==0 is correct
>>>>>>>  > It is the case that H1((P,P)==1 is correct
>>>>>>>  > It is the case the this is inconsistent.
>>>>>>>  > It is the case that this inconsistency
>>>>>>>
>>>>>>>  > defines a decidability decider that correctly
>>>>>>>  > defines a decidability decider that correctly
>>>>>>>  > defines a decidability decider that correctly
>>>>>>>
>>>>>>>  > rejects P on the basis that P has the
>>>>>>>  > pathological self-reference(Olcott 2004) error.
>>>>>>
>>>>>> So what exactly is it that the above is deciding? And how does
>>>>>> this relate to Rice? If you want to claim this is somehow related
>>>>>> to rice, you need to identify some semantic property that you
>>>>>> claim to be able to decide.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> It is deciding that either H/P or H1/P form the pathological
>>>>> self-reference error(Olcott 2004). As I said in 2004 this is the
>>>>> same error as the Liar Paradox. This means that either H/P or H1/P
>>>>> are not correctly decidable.
>>>>
>>>> The post in which I mentioned a 'decider decider' which you somehow
>>>> misread as 'decidability decider' was intended to clarify a single
>>>> sentence from an earlier post which you entirely ignored. Why don't
>>>> you go back and actually read that earlier post and address the
>>>> points made therein.
>>>>
>>>> Your ill-defined notion of a 'pathological self-reference error'
>>>> doesn't appear to be a property of a Turing Machine, which is what
>>>> Rice's theorem is concerned with. To the extent that it is a
>>>> property at all, it appears to be a property of specific
>>>> computations, so this has absolutely no relevance to Rice.
>>>>
>>>> André
>>>>
>>>
>>> It is the property of H(P,P).
>>
>> Right, which means this is entirely irrelevant to Rice's theorem.
>>
>
> Many historical posts in comp.theory say otherwise.
> If a function can be provided that correctly decides that a specific TM
> cannot correctly decide a specific input pair (according to many
> historical posts on comp.theory) this does refute Rice's theorem.

So what is the semantic property *of P* that you claim your
PSR_Olcott_2004 is capable of identifying?

You can't claim that there is anything 'erroneous' about P. There isn't.

The fact that you run into a problem when you pass a description of P to
some *other* TM is not an indicator that there is something wrong with
P. That's like saying that the expression 40 + 50 is 'erroneous' because
I can't pass it as an argument to tangent().

>>> u32 PSR_Olcott_2004(u32 P)
>>> {
>>>    return H1(P,P) != H(P,P);
>>> }
>>>
>>> Decides that H(P,P) cannot correctly decide the halt status of its
>>> input,
>>
>>
>> No, it does not. It decides that the results of H1(P, P) doesn't match
>> the results of H(P, P). It 'decides' that one of these is correct and
>> the other is not but it cannot tell you which one, which means it
>> can't decide whether H(P, P) can correctly decide the halt status of
>> its input.
>>
>
> I simply have not gotten to that part yet.

And yet you claimed to be able to 'decide' that H(P, P) cannot correctly
decide the halt status of its input. Until you actually 'get to that
part' you have no business making such a claim.

>>> thus a semantic property of H relative to P.
>>
>> That's not a property (semantic or otherwise) of *either* P or H.
>>
>>> The Liar Paradox works this same way.
>>
>> The liar's paradox is completely irrelevant to Linz.
>>
>> André
>>
>
> The pathological self-reference error (Olcott 2004) is specifically
> relevant to:
> (a) The Halting Theorem
> (b) The 1931 Incompleteness Theorem
> (c) The Tarski undefinability theorem
> (d) The Liar Paradox (upon which (c) is based).

So why don't you:

(a) provide a proper definition of "pathological self-reference error"
That means a definition which will allow one to unambiguosly
determine whether an arbitrary expression/entity has this error.
(b) explain in what sense an "error" is a property.
(c) demonstrate that whatever property you are referring to is a
*semantic* property.

André

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

On 9/19/2021 11:07 AM, olcott wrote:
> The pathological self-reference error (Olcott 2004) is specifically
> relevant to:
> (a) The Halting Theorem
> (b) The 1931 Incompleteness Theorem
> (c) The Tarski undefinability theorem
> (d) The Liar Paradox (upon which (c) is based).

Nothing you have done in the past two decades seems to be relevant to
anything. Seems? Just being polite. Actually, why bother: Nothing you
have done in the past two decades is relevant to anything. How long has
your illness made your brain dysfunctional? Friendly reminders: don't
get ahead of yourself; take your meds, all of them.

There are only two paths to long lasting fame for yourself: The first is
to write the USENET version of "The Trisectors" by Underwood Duddley.
The second is to collect two decades of your idiotic newsgroup threads
and turn them into a classic entitled "How to Go Directly from Stark
Personal Depression to Being a World Class Self-Deluded Troll Without
Missing a Meal."

The latter suggestion would be enhanced if you could put your
publication in an academic series with "How To Go Directly Into Solo Law
Practice Without Missing a Meal" by Gerald M. Singer (an LA lawyer).
Fame and notoriety all based on your original works awaits you. And now
we see how all those clever copyright annotations are going to pay off
with big bucks.
--
Jeff Barnett

On 9/19/21 11:46 AM, olcott wrote:
> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>> On 2021-09-19 08:34, olcott wrote:
>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>
>>>>> And note that Rice is talking about properties of Turing Machines
>>>>> (or, more properly, of the language accepted by a TM), not
>>>>> computations.
>>>>
>>>> I realized immediately after hitting 'send' that the above will no
>>>> doubt confuse you since people have been telling you that Turing
>>>> Machines can only express computations whereas C/x86 aren't thus
>>>> constrained.
>>>>
>>>> A computation is a Turing Machine description PLUS an input string.
>>>>
>>>> Rice's theorem is concerned with the Turing Machine's themselves.
>>>>
>>>> The Linz proof shows that you cannot construct a halting decider,
>>>> i.e. a decider which correctly determines for any given TM + input
>>>> string pair, whether that pair represents a halting computation.
>>>>
>>>> Rice's theorem, on the other hand, would rule out the construction
>>>> of something like a Decider Decider, i.e. a TM which takes as its
>>>> input a TM description and determines whether that TM qualifies as a
>>>> decider, i.e. is guaranteed to halt on *any* possible input.
>>>>
>>>> André
>>>>
>>>
>>> Here is where I referred to my code defining a
>>> a decidability decider nine days before you did:
>>
>> Where did I define or even mention a 'decidability decider'? Above I
>> discussed (but did not define) a DECIDER decider, i.e. a TM which
>> determines whether another TM qualifies as a decider.
>>
>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>  > It is the case that H(P,P)==0 is correct
>>>  > It is the case that H1((P,P)==1 is correct
>>>  > It is the case the this is inconsistent.
>>>  > It is the case that this inconsistency
>>>
>>>  > defines a decidability decider that correctly
>>>  > defines a decidability decider that correctly
>>>  > defines a decidability decider that correctly
>>>
>>>  > rejects P on the basis that P has the
>>>  > pathological self-reference(Olcott 2004) error.
>>
>> So what exactly is it that the above is deciding? And how does this
>> relate to Rice? If you want to claim this is somehow related to rice,
>> you need to identify some semantic property that you claim to be able
>> to decide.
>>
>> André
>>
>
> It is deciding that either H/P or H1/P form the pathological
> self-reference error(Olcott 2004). As I said in 2004 this is the same
> error as the Liar Paradox. This means that either H/P or H1/P are not
> correctly decidable.
>

Except that P, in both cases is most definitely decidable, just not by a
given decider.

Thus, the error is NOT in P, but with H.

On 9/19/2021 12:25 PM, André G. Isaak wrote:
> On 2021-09-19 11:07, olcott wrote:
>> On 9/19/2021 11:56 AM, André G. Isaak wrote:
>>> On 2021-09-19 10:39, olcott wrote:
>>>> On 9/19/2021 11:11 AM, André G. Isaak wrote:
>>>>> On 2021-09-19 09:46, olcott wrote:
>>>>>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>>>>>> On 2021-09-19 08:34, olcott wrote:
>>>>>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>>>>>
>>>>>>>>>> And note that Rice is talking about properties of Turing
>>>>>>>>>> Machines (or, more properly, of the language accepted by a
>>>>>>>>>> TM), not computations.
>>>>>>>>>
>>>>>>>>> I realized immediately after hitting 'send' that the above will
>>>>>>>>> no doubt confuse you since people have been telling you that
>>>>>>>>> Turing Machines can only express computations whereas C/x86
>>>>>>>>> aren't thus constrained.
>>>>>>>>>
>>>>>>>>> A computation is a Turing Machine description PLUS an input
>>>>>>>>> string.
>>>>>>>>>
>>>>>>>>> Rice's theorem is concerned with the Turing Machine's themselves.
>>>>>>>>>
>>>>>>>>> The Linz proof shows that you cannot construct a halting
>>>>>>>>> decider, i.e. a decider which correctly determines for any
>>>>>>>>> given TM + input string pair, whether that pair represents a
>>>>>>>>> halting computation.
>>>>>>>>>
>>>>>>>>> Rice's theorem, on the other hand, would rule out the
>>>>>>>>> construction of something like a Decider Decider, i.e. a TM
>>>>>>>>> which takes as its input a TM description and determines
>>>>>>>>> whether that TM qualifies as a decider, i.e. is guaranteed to
>>>>>>>>> halt on *any* possible input.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> Here is where I referred to my code defining a
>>>>>>>> a decidability decider nine days before you did:
>>>>>>>
>>>>>>> Where did I define or even mention a 'decidability decider'?
>>>>>>> Above I discussed (but did not define) a DECIDER decider, i.e. a
>>>>>>> TM which determines whether another TM qualifies as a decider.
>>>>>>>
>>>>>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>>>>>  > It is the case that H(P,P)==0 is correct
>>>>>>>>  > It is the case that H1((P,P)==1 is correct
>>>>>>>>  > It is the case the this is inconsistent.
>>>>>>>>  > It is the case that this inconsistency
>>>>>>>>
>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>
>>>>>>>>  > rejects P on the basis that P has the
>>>>>>>>  > pathological self-reference(Olcott 2004) error.
>>>>>>>
>>>>>>> So what exactly is it that the above is deciding? And how does
>>>>>>> this relate to Rice? If you want to claim this is somehow related
>>>>>>> to rice, you need to identify some semantic property that you
>>>>>>> claim to be able to decide.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> It is deciding that either H/P or H1/P form the pathological
>>>>>> self-reference error(Olcott 2004). As I said in 2004 this is the
>>>>>> same error as the Liar Paradox. This means that either H/P or H1/P
>>>>>> are not correctly decidable.
>>>>>
>>>>> The post in which I mentioned a 'decider decider' which you somehow
>>>>> misread as 'decidability decider' was intended to clarify a single
>>>>> sentence from an earlier post which you entirely ignored. Why don't
>>>>> you go back and actually read that earlier post and address the
>>>>> points made therein.
>>>>>
>>>>> Your ill-defined notion of a 'pathological self-reference error'
>>>>> doesn't appear to be a property of a Turing Machine, which is what
>>>>> Rice's theorem is concerned with. To the extent that it is a
>>>>> property at all, it appears to be a property of specific
>>>>> computations, so this has absolutely no relevance to Rice.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> It is the property of H(P,P).
>>>
>>> Right, which means this is entirely irrelevant to Rice's theorem.
>>>
>>
>> Many historical posts in comp.theory say otherwise.
>> If a function can be provided that correctly decides that a specific
>> TM cannot correctly decide a specific input pair (according to many
>> historical posts on comp.theory) this does refute Rice's theorem.
>
> So what is the semantic property *of P* that you claim your
> PSR_Olcott_2004 is capable of identifying?
>
> You can't claim that there is anything 'erroneous' about P. There isn't.
>
> The fact that you run into a problem when you pass a description of P to
> some *other* TM is not an indicator that there is something wrong with
> P. That's like saying that the expression 40 + 50 is 'erroneous' because
> I can't pass it as an argument to tangent().
>
>>>> u32 PSR_Olcott_2004(u32 P)
>>>> {
>>>>    return H1(P,P) != H(P,P);
>>>> }
>>>>
>>>> Decides that H(P,P) cannot correctly decide the halt status of its
>>>> input,
>>>
>>>
>>> No, it does not. It decides that the results of H1(P, P) doesn't
>>> match the results of H(P, P). It 'decides' that one of these is
>>> correct and the other is not but it cannot tell you which one, which
>>> means it can't decide whether H(P, P) can correctly decide the halt
>>> status of its input.
>>>
>>
>> I simply have not gotten to that part yet.
>
> And yet you claimed to be able to 'decide' that H(P, P) cannot correctly
> decide the halt status of its input. Until you actually 'get to that
> part' you have no business making such a claim.
>

Odd man out:
When H1(P,P) != H(P,P) we test
HX(P,P) != H1(P,P)
HX(P,P) != H(P,P)

The one that HX(P,P) agrees with is the correct one.

>>>> thus a semantic property of H relative to P.
>>>
>>> That's not a property (semantic or otherwise) of *either* P or H.
>>>
>>>> The Liar Paradox works this same way.
>>>
>>> The liar's paradox is completely irrelevant to Linz.
>>>
>>> André
>>>
>>
>> The pathological self-reference error (Olcott 2004) is specifically
>> relevant to:
>> (a) The Halting Theorem
>> (b) The 1931 Incompleteness Theorem
>> (c) The Tarski undefinability theorem
>> (d) The Liar Paradox (upon which (c) is based).
>
> So why don't you:
>
> (a) provide a proper definition of "pathological self-reference error"
>     That means a definition which will allow one to unambiguosly
> determine whether an arbitrary expression/entity has this error.

I just provided a reference to function that correctly decide this.
As long as my "pure function of its inputs" becomes fully validated
I will be able to provide the actual source-code that makes this decision.

> (b) explain in what sense an "error" is a property.
> (c) demonstrate that whatever property you are referring to is a
> *semantic* property.
>
> André
>

On 2021-09-19 11:54, olcott wrote:
> On 9/19/2021 12:25 PM, André G. Isaak wrote:
>> On 2021-09-19 11:07, olcott wrote:
>>> On 9/19/2021 11:56 AM, André G. Isaak wrote:
>>>> On 2021-09-19 10:39, olcott wrote:
>>>>> On 9/19/2021 11:11 AM, André G. Isaak wrote:
>>>>>> On 2021-09-19 09:46, olcott wrote:
>>>>>>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>>>>>>> On 2021-09-19 08:34, olcott wrote:
>>>>>>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>>>>>>
>>>>>>>>>>> And note that Rice is talking about properties of Turing
>>>>>>>>>>> Machines (or, more properly, of the language accepted by a
>>>>>>>>>>> TM), not computations.
>>>>>>>>>>
>>>>>>>>>> I realized immediately after hitting 'send' that the above
>>>>>>>>>> will no doubt confuse you since people have been telling you
>>>>>>>>>> that Turing Machines can only express computations whereas
>>>>>>>>>> C/x86 aren't thus constrained.
>>>>>>>>>>
>>>>>>>>>> A computation is a Turing Machine description PLUS an input
>>>>>>>>>> string.
>>>>>>>>>>
>>>>>>>>>> Rice's theorem is concerned with the Turing Machine's themselves.
>>>>>>>>>>
>>>>>>>>>> The Linz proof shows that you cannot construct a halting
>>>>>>>>>> decider, i.e. a decider which correctly determines for any
>>>>>>>>>> given TM + input string pair, whether that pair represents a
>>>>>>>>>> halting computation.
>>>>>>>>>>
>>>>>>>>>> Rice's theorem, on the other hand, would rule out the
>>>>>>>>>> construction of something like a Decider Decider, i.e. a TM
>>>>>>>>>> which takes as its input a TM description and determines
>>>>>>>>>> whether that TM qualifies as a decider, i.e. is guaranteed to
>>>>>>>>>> halt on *any* possible input.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Here is where I referred to my code defining a
>>>>>>>>> a decidability decider nine days before you did:
>>>>>>>>
>>>>>>>> Where did I define or even mention a 'decidability decider'?
>>>>>>>> Above I discussed (but did not define) a DECIDER decider, i.e. a
>>>>>>>> TM which determines whether another TM qualifies as a decider.
>>>>>>>>
>>>>>>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>>>>>>  > It is the case that H(P,P)==0 is correct
>>>>>>>>>  > It is the case that H1((P,P)==1 is correct
>>>>>>>>>  > It is the case the this is inconsistent.
>>>>>>>>>  > It is the case that this inconsistency
>>>>>>>>>
>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>
>>>>>>>>>  > rejects P on the basis that P has the
>>>>>>>>>  > pathological self-reference(Olcott 2004) error.
>>>>>>>>
>>>>>>>> So what exactly is it that the above is deciding? And how does
>>>>>>>> this relate to Rice? If you want to claim this is somehow
>>>>>>>> related to rice, you need to identify some semantic property
>>>>>>>> that you claim to be able to decide.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> It is deciding that either H/P or H1/P form the pathological
>>>>>>> self-reference error(Olcott 2004). As I said in 2004 this is the
>>>>>>> same error as the Liar Paradox. This means that either H/P or
>>>>>>> H1/P are not correctly decidable.
>>>>>>
>>>>>> The post in which I mentioned a 'decider decider' which you
>>>>>> somehow misread as 'decidability decider' was intended to clarify
>>>>>> a single sentence from an earlier post which you entirely ignored.
>>>>>> Why don't you go back and actually read that earlier post and
>>>>>> address the points made therein.
>>>>>>
>>>>>> Your ill-defined notion of a 'pathological self-reference error'
>>>>>> doesn't appear to be a property of a Turing Machine, which is what
>>>>>> Rice's theorem is concerned with. To the extent that it is a
>>>>>> property at all, it appears to be a property of specific
>>>>>> computations, so this has absolutely no relevance to Rice.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> It is the property of H(P,P).
>>>>
>>>> Right, which means this is entirely irrelevant to Rice's theorem.
>>>>
>>>
>>> Many historical posts in comp.theory say otherwise.
>>> If a function can be provided that correctly decides that a specific
>>> TM cannot correctly decide a specific input pair (according to many
>>> historical posts on comp.theory) this does refute Rice's theorem.
>>
>> So what is the semantic property *of P* that you claim your
>> PSR_Olcott_2004 is capable of identifying?
>>
>> You can't claim that there is anything 'erroneous' about P. There isn't.
>>
>> The fact that you run into a problem when you pass a description of P
>> to some *other* TM is not an indicator that there is something wrong
>> with P. That's like saying that the expression 40 + 50 is 'erroneous'
>> because I can't pass it as an argument to tangent().
>>
>>>>> u32 PSR_Olcott_2004(u32 P)
>>>>> {
>>>>>    return H1(P,P) != H(P,P);
>>>>> }
>>>>>
>>>>> Decides that H(P,P) cannot correctly decide the halt status of its
>>>>> input,
>>>>
>>>>
>>>> No, it does not. It decides that the results of H1(P, P) doesn't
>>>> match the results of H(P, P). It 'decides' that one of these is
>>>> correct and the other is not but it cannot tell you which one, which
>>>> means it can't decide whether H(P, P) can correctly decide the halt
>>>> status of its input.
>>>>
>>>
>>> I simply have not gotten to that part yet.
>>
>> And yet you claimed to be able to 'decide' that H(P, P) cannot
>> correctly decide the halt status of its input. Until you actually 'get
>> to that part' you have no business making such a claim.
>>
>
> Odd man out:
> When H1(P,P) != H(P,P) we test
>   HX(P,P) != H1(P,P)
>   HX(P,P) != H(P,P)
>
> The one that HX(P,P) agrees with is the correct one.

There are a potentially infinite number of Hns. Your 'decider' only
qualifies as a decider if it works for *every* one of them. Your 'odd
man out strategy' only works if the case you are testing happens to be
among the three which are included in your test function.

>>>>> thus a semantic property of H relative to P.
>>>>
>>>> That's not a property (semantic or otherwise) of *either* P or H.
>>>>
>>>>> The Liar Paradox works this same way.
>>>>
>>>> The liar's paradox is completely irrelevant to Linz.
>>>>
>>>> André
>>>>
>>>
>>> The pathological self-reference error (Olcott 2004) is specifically
>>> relevant to:
>>> (a) The Halting Theorem
>>> (b) The 1931 Incompleteness Theorem
>>> (c) The Tarski undefinability theorem
>>> (d) The Liar Paradox (upon which (c) is based).
>>
>> So why don't you:
>>
>> (a) provide a proper definition of "pathological self-reference error"
>>      That means a definition which will allow one to unambiguosly
>> determine whether an arbitrary expression/entity has this error.
>
> I just provided a reference to function that correctly decide this.

On 9/19/2021 1:24 PM, André G. Isaak wrote:
> On 2021-09-19 11:54, olcott wrote:
>> On 9/19/2021 12:25 PM, André G. Isaak wrote:
>>> On 2021-09-19 11:07, olcott wrote:
>>>> On 9/19/2021 11:56 AM, André G. Isaak wrote:
>>>>> On 2021-09-19 10:39, olcott wrote:
>>>>>> On 9/19/2021 11:11 AM, André G. Isaak wrote:
>>>>>>> On 2021-09-19 09:46, olcott wrote:
>>>>>>>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>>>>>>>> On 2021-09-19 08:34, olcott wrote:
>>>>>>>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>>>>>>>
>>>>>>>>>>>> And note that Rice is talking about properties of Turing
>>>>>>>>>>>> Machines (or, more properly, of the language accepted by a
>>>>>>>>>>>> TM), not computations.
>>>>>>>>>>>
>>>>>>>>>>> I realized immediately after hitting 'send' that the above
>>>>>>>>>>> will no doubt confuse you since people have been telling you
>>>>>>>>>>> that Turing Machines can only express computations whereas
>>>>>>>>>>> C/x86 aren't thus constrained.
>>>>>>>>>>>
>>>>>>>>>>> A computation is a Turing Machine description PLUS an input
>>>>>>>>>>> string.
>>>>>>>>>>>
>>>>>>>>>>> Rice's theorem is concerned with the Turing Machine's
>>>>>>>>>>> themselves.
>>>>>>>>>>>
>>>>>>>>>>> The Linz proof shows that you cannot construct a halting
>>>>>>>>>>> decider, i.e. a decider which correctly determines for any
>>>>>>>>>>> given TM + input string pair, whether that pair represents a
>>>>>>>>>>> halting computation.
>>>>>>>>>>>
>>>>>>>>>>> Rice's theorem, on the other hand, would rule out the
>>>>>>>>>>> construction of something like a Decider Decider, i.e. a TM
>>>>>>>>>>> which takes as its input a TM description and determines
>>>>>>>>>>> whether that TM qualifies as a decider, i.e. is guaranteed to
>>>>>>>>>>> halt on *any* possible input.
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Here is where I referred to my code defining a
>>>>>>>>>> a decidability decider nine days before you did:
>>>>>>>>>
>>>>>>>>> Where did I define or even mention a 'decidability decider'?
>>>>>>>>> Above I discussed (but did not define) a DECIDER decider, i.e.
>>>>>>>>> a TM which determines whether another TM qualifies as a decider.
>>>>>>>>>
>>>>>>>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>>>>>>>  > It is the case that H(P,P)==0 is correct
>>>>>>>>>>  > It is the case that H1((P,P)==1 is correct
>>>>>>>>>>  > It is the case the this is inconsistent.
>>>>>>>>>>  > It is the case that this inconsistency
>>>>>>>>>>
>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>
>>>>>>>>>>  > rejects P on the basis that P has the
>>>>>>>>>>  > pathological self-reference(Olcott 2004) error.
>>>>>>>>>
>>>>>>>>> So what exactly is it that the above is deciding? And how does
>>>>>>>>> this relate to Rice? If you want to claim this is somehow
>>>>>>>>> related to rice, you need to identify some semantic property
>>>>>>>>> that you claim to be able to decide.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is deciding that either H/P or H1/P form the pathological
>>>>>>>> self-reference error(Olcott 2004). As I said in 2004 this is the
>>>>>>>> same error as the Liar Paradox. This means that either H/P or
>>>>>>>> H1/P are not correctly decidable.
>>>>>>>
>>>>>>> The post in which I mentioned a 'decider decider' which you
>>>>>>> somehow misread as 'decidability decider' was intended to clarify
>>>>>>> a single sentence from an earlier post which you entirely
>>>>>>> ignored. Why don't you go back and actually read that earlier
>>>>>>> post and address the points made therein.
>>>>>>>
>>>>>>> Your ill-defined notion of a 'pathological self-reference error'
>>>>>>> doesn't appear to be a property of a Turing Machine, which is
>>>>>>> what Rice's theorem is concerned with. To the extent that it is a
>>>>>>> property at all, it appears to be a property of specific
>>>>>>> computations, so this has absolutely no relevance to Rice.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> It is the property of H(P,P).
>>>>>
>>>>> Right, which means this is entirely irrelevant to Rice's theorem.
>>>>>
>>>>
>>>> Many historical posts in comp.theory say otherwise.
>>>> If a function can be provided that correctly decides that a specific
>>>> TM cannot correctly decide a specific input pair (according to many
>>>> historical posts on comp.theory) this does refute Rice's theorem.
>>>
>>> So what is the semantic property *of P* that you claim your
>>> PSR_Olcott_2004 is capable of identifying?
>>>
>>> You can't claim that there is anything 'erroneous' about P. There isn't.
>>>
>>> The fact that you run into a problem when you pass a description of P
>>> to some *other* TM is not an indicator that there is something wrong
>>> with P. That's like saying that the expression 40 + 50 is 'erroneous'
>>> because I can't pass it as an argument to tangent().
>>>
>>>>>> u32 PSR_Olcott_2004(u32 P)
>>>>>> {
>>>>>>    return H1(P,P) != H(P,P);
>>>>>> }
>>>>>>
>>>>>> Decides that H(P,P) cannot correctly decide the halt status of its
>>>>>> input,
>>>>>
>>>>>
>>>>> No, it does not. It decides that the results of H1(P, P) doesn't
>>>>> match the results of H(P, P). It 'decides' that one of these is
>>>>> correct and the other is not but it cannot tell you which one,
>>>>> which means it can't decide whether H(P, P) can correctly decide
>>>>> the halt status of its input.
>>>>>
>>>>
>>>> I simply have not gotten to that part yet.
>>>
>>> And yet you claimed to be able to 'decide' that H(P, P) cannot
>>> correctly decide the halt status of its input. Until you actually
>>> 'get to that part' you have no business making such a claim.
>>>
>>
>> Odd man out:
>> When H1(P,P) != H(P,P) we test
>>    HX(P,P) != H1(P,P)
>>    HX(P,P) != H(P,P)
>>
>> The one that HX(P,P) agrees with is the correct one.
>
> There are a potentially infinite number of Hns. Your 'decider' only
> qualifies as a decider if it works for *every* one of them. Your 'odd
> man out strategy' only works if the case you are testing happens to be
> among the three which are included in your test function.
>

On 9/19/21 2:33 PM, olcott wrote:
> On 9/19/2021 1:24 PM, André G. Isaak wrote:
>> On 2021-09-19 11:54, olcott wrote:
>>> On 9/19/2021 12:25 PM, André G. Isaak wrote:
>>>> On 2021-09-19 11:07, olcott wrote:
>>>>> On 9/19/2021 11:56 AM, André G. Isaak wrote:
>>>>>> On 2021-09-19 10:39, olcott wrote:
>>>>>>> On 9/19/2021 11:11 AM, André G. Isaak wrote:
>>>>>>>> On 2021-09-19 09:46, olcott wrote:
>>>>>>>>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>>>>>>>>> On 2021-09-19 08:34, olcott wrote:
>>>>>>>>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> And note that Rice is talking about properties of Turing
>>>>>>>>>>>>> Machines (or, more properly, of the language accepted by a
>>>>>>>>>>>>> TM), not computations.
>>>>>>>>>>>>
>>>>>>>>>>>> I realized immediately after hitting 'send' that the above
>>>>>>>>>>>> will no doubt confuse you since people have been telling you
>>>>>>>>>>>> that Turing Machines can only express computations whereas
>>>>>>>>>>>> C/x86 aren't thus constrained.
>>>>>>>>>>>>
>>>>>>>>>>>> A computation is a Turing Machine description PLUS an input
>>>>>>>>>>>> string.
>>>>>>>>>>>>
>>>>>>>>>>>> Rice's theorem is concerned with the Turing Machine's
>>>>>>>>>>>> themselves.
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz proof shows that you cannot construct a halting
>>>>>>>>>>>> decider, i.e. a decider which correctly determines for any
>>>>>>>>>>>> given TM + input string pair, whether that pair represents a
>>>>>>>>>>>> halting computation.
>>>>>>>>>>>>
>>>>>>>>>>>> Rice's theorem, on the other hand, would rule out the
>>>>>>>>>>>> construction of something like a Decider Decider, i.e. a TM
>>>>>>>>>>>> which takes as its input a TM description and determines
>>>>>>>>>>>> whether that TM qualifies as a decider, i.e. is guaranteed
>>>>>>>>>>>> to halt on *any* possible input.
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Here is where I referred to my code defining a
>>>>>>>>>>> a decidability decider nine days before you did:
>>>>>>>>>>
>>>>>>>>>> Where did I define or even mention a 'decidability decider'?
>>>>>>>>>> Above I discussed (but did not define) a DECIDER decider, i.e.
>>>>>>>>>> a TM which determines whether another TM qualifies as a decider.
>>>>>>>>>>
>>>>>>>>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>>>>>>>>  > It is the case that H(P,P)==0 is correct
>>>>>>>>>>>  > It is the case that H1((P,P)==1 is correct
>>>>>>>>>>>  > It is the case the this is inconsistent.
>>>>>>>>>>>  > It is the case that this inconsistency
>>>>>>>>>>>
>>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>>
>>>>>>>>>>>  > rejects P on the basis that P has the
>>>>>>>>>>>  > pathological self-reference(Olcott 2004) error.
>>>>>>>>>>
>>>>>>>>>> So what exactly is it that the above is deciding? And how does
>>>>>>>>>> this relate to Rice? If you want to claim this is somehow
>>>>>>>>>> related to rice, you need to identify some semantic property
>>>>>>>>>> that you claim to be able to decide.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is deciding that either H/P or H1/P form the pathological
>>>>>>>>> self-reference error(Olcott 2004). As I said in 2004 this is
>>>>>>>>> the same error as the Liar Paradox. This means that either H/P
>>>>>>>>> or H1/P are not correctly decidable.
>>>>>>>>
>>>>>>>> The post in which I mentioned a 'decider decider' which you
>>>>>>>> somehow misread as 'decidability decider' was intended to
>>>>>>>> clarify a single sentence from an earlier post which you
>>>>>>>> entirely ignored. Why don't you go back and actually read that
>>>>>>>> earlier post and address the points made therein.
>>>>>>>>
>>>>>>>> Your ill-defined notion of a 'pathological self-reference error'
>>>>>>>> doesn't appear to be a property of a Turing Machine, which is
>>>>>>>> what Rice's theorem is concerned with. To the extent that it is
>>>>>>>> a property at all, it appears to be a property of specific
>>>>>>>> computations, so this has absolutely no relevance to Rice.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> It is the property of H(P,P).
>>>>>>
>>>>>> Right, which means this is entirely irrelevant to Rice's theorem.
>>>>>>
>>>>>
>>>>> Many historical posts in comp.theory say otherwise.
>>>>> If a function can be provided that correctly decides that a
>>>>> specific TM cannot correctly decide a specific input pair
>>>>> (according to many historical posts on comp.theory) this does
>>>>> refute Rice's theorem.
>>>>
>>>> So what is the semantic property *of P* that you claim your
>>>> PSR_Olcott_2004 is capable of identifying?
>>>>
>>>> You can't claim that there is anything 'erroneous' about P. There
>>>> isn't.
>>>>
>>>> The fact that you run into a problem when you pass a description of
>>>> P to some *other* TM is not an indicator that there is something
>>>> wrong with P. That's like saying that the expression 40 + 50 is
>>>> 'erroneous' because I can't pass it as an argument to tangent().
>>>>
>>>>>>> u32 PSR_Olcott_2004(u32 P)
>>>>>>> {
>>>>>>>    return H1(P,P) != H(P,P);
>>>>>>> }
>>>>>>>
>>>>>>> Decides that H(P,P) cannot correctly decide the halt status of
>>>>>>> its input,
>>>>>>
>>>>>>
>>>>>> No, it does not. It decides that the results of H1(P, P) doesn't
>>>>>> match the results of H(P, P). It 'decides' that one of these is
>>>>>> correct and the other is not but it cannot tell you which one,
>>>>>> which means it can't decide whether H(P, P) can correctly decide
>>>>>> the halt status of its input.
>>>>>>
>>>>>
>>>>> I simply have not gotten to that part yet.
>>>>
>>>> And yet you claimed to be able to 'decide' that H(P, P) cannot
>>>> correctly decide the halt status of its input. Until you actually
>>>> 'get to that part' you have no business making such a claim.
>>>>
>>>
>>> Odd man out:
>>> When H1(P,P) != H(P,P) we test
>>>    HX(P,P) != H1(P,P)
>>>    HX(P,P) != H(P,P)
>>>
>>> The one that HX(P,P) agrees with is the correct one.
>>
>> There are a potentially infinite number of Hns. Your 'decider' only
>> qualifies as a decider if it works for *every* one of them. Your 'odd
>> man out strategy' only works if the case you are testing happens to be
>> among the three which are included in your test function.
>>
>
> The halting theorem is based on an artificially contrived example that
> would never actually occur in actual practice. In actual practice we
> would only actually need H.

On 19/09/2021 19:33, olcott wrote:
> The halting theorem is based on an artificially contrived example

Not the /theorem/; one particular proof [of several well-
known proofs] is based on that, others are not.

> that would never actually occur in actual practice.

Depends what you mean by "actual practice"; it occurs
[subject to the caveat in my next paragraph] rather often in
discussions of the HP, and it occurs [ditto] in almost all C
programs [just as the sequence 31415926535 occurs in the decimal
expansion of almost all integers, though rarely in those with
relatively few digits].

> In actual
> practice we would only actually need H.

You do realise that the program "H" doesn't actually
exist? So it is at least as rare/artificial as "H^".

> The odd-man-out system does correctly decide an input that was
> artificially contrived to specifically have the pathological
> self-reference error (Olcott 2004) for either H or H1. All of the
> rest of the cases are simply correctly decided by either H or H1.

No they aren't; by Rice's theorem if for no other
reason, assuming that you eventually manage to produce a
workable definition of "pathological self-reference".

--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Dvorak

On 2021-09-19 12:33, olcott wrote:
> On 9/19/2021 1:24 PM, André G. Isaak wrote:
>> On 2021-09-19 11:54, olcott wrote:
>>> On 9/19/2021 12:25 PM, André G. Isaak wrote:
>>>> On 2021-09-19 11:07, olcott wrote:
>>>>> On 9/19/2021 11:56 AM, André G. Isaak wrote:
>>>>>> On 2021-09-19 10:39, olcott wrote:
>>>>>>> On 9/19/2021 11:11 AM, André G. Isaak wrote:
>>>>>>>> On 2021-09-19 09:46, olcott wrote:
>>>>>>>>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>>>>>>>>> On 2021-09-19 08:34, olcott wrote:
>>>>>>>>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> And note that Rice is talking about properties of Turing
>>>>>>>>>>>>> Machines (or, more properly, of the language accepted by a
>>>>>>>>>>>>> TM), not computations.
>>>>>>>>>>>>
>>>>>>>>>>>> I realized immediately after hitting 'send' that the above
>>>>>>>>>>>> will no doubt confuse you since people have been telling you
>>>>>>>>>>>> that Turing Machines can only express computations whereas
>>>>>>>>>>>> C/x86 aren't thus constrained.
>>>>>>>>>>>>
>>>>>>>>>>>> A computation is a Turing Machine description PLUS an input
>>>>>>>>>>>> string.
>>>>>>>>>>>>
>>>>>>>>>>>> Rice's theorem is concerned with the Turing Machine's
>>>>>>>>>>>> themselves.
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz proof shows that you cannot construct a halting
>>>>>>>>>>>> decider, i.e. a decider which correctly determines for any
>>>>>>>>>>>> given TM + input string pair, whether that pair represents a
>>>>>>>>>>>> halting computation.
>>>>>>>>>>>>
>>>>>>>>>>>> Rice's theorem, on the other hand, would rule out the
>>>>>>>>>>>> construction of something like a Decider Decider, i.e. a TM
>>>>>>>>>>>> which takes as its input a TM description and determines
>>>>>>>>>>>> whether that TM qualifies as a decider, i.e. is guaranteed
>>>>>>>>>>>> to halt on *any* possible input.
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Here is where I referred to my code defining a
>>>>>>>>>>> a decidability decider nine days before you did:
>>>>>>>>>>
>>>>>>>>>> Where did I define or even mention a 'decidability decider'?
>>>>>>>>>> Above I discussed (but did not define) a DECIDER decider, i.e.
>>>>>>>>>> a TM which determines whether another TM qualifies as a decider.
>>>>>>>>>>
>>>>>>>>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>>>>>>>>  > It is the case that H(P,P)==0 is correct
>>>>>>>>>>>  > It is the case that H1((P,P)==1 is correct
>>>>>>>>>>>  > It is the case the this is inconsistent.
>>>>>>>>>>>  > It is the case that this inconsistency
>>>>>>>>>>>
>>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>>
>>>>>>>>>>>  > rejects P on the basis that P has the
>>>>>>>>>>>  > pathological self-reference(Olcott 2004) error.
>>>>>>>>>>
>>>>>>>>>> So what exactly is it that the above is deciding? And how does
>>>>>>>>>> this relate to Rice? If you want to claim this is somehow
>>>>>>>>>> related to rice, you need to identify some semantic property
>>>>>>>>>> that you claim to be able to decide.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is deciding that either H/P or H1/P form the pathological
>>>>>>>>> self-reference error(Olcott 2004). As I said in 2004 this is
>>>>>>>>> the same error as the Liar Paradox. This means that either H/P
>>>>>>>>> or H1/P are not correctly decidable.
>>>>>>>>
>>>>>>>> The post in which I mentioned a 'decider decider' which you
>>>>>>>> somehow misread as 'decidability decider' was intended to
>>>>>>>> clarify a single sentence from an earlier post which you
>>>>>>>> entirely ignored. Why don't you go back and actually read that
>>>>>>>> earlier post and address the points made therein.
>>>>>>>>
>>>>>>>> Your ill-defined notion of a 'pathological self-reference error'
>>>>>>>> doesn't appear to be a property of a Turing Machine, which is
>>>>>>>> what Rice's theorem is concerned with. To the extent that it is
>>>>>>>> a property at all, it appears to be a property of specific
>>>>>>>> computations, so this has absolutely no relevance to Rice.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> It is the property of H(P,P).
>>>>>>
>>>>>> Right, which means this is entirely irrelevant to Rice's theorem.
>>>>>>
>>>>>
>>>>> Many historical posts in comp.theory say otherwise.
>>>>> If a function can be provided that correctly decides that a
>>>>> specific TM cannot correctly decide a specific input pair
>>>>> (according to many historical posts on comp.theory) this does
>>>>> refute Rice's theorem.
>>>>
>>>> So what is the semantic property *of P* that you claim your
>>>> PSR_Olcott_2004 is capable of identifying?
>>>>
>>>> You can't claim that there is anything 'erroneous' about P. There
>>>> isn't.
>>>>
>>>> The fact that you run into a problem when you pass a description of
>>>> P to some *other* TM is not an indicator that there is something
>>>> wrong with P. That's like saying that the expression 40 + 50 is
>>>> 'erroneous' because I can't pass it as an argument to tangent().
>>>>
>>>>>>> u32 PSR_Olcott_2004(u32 P)
>>>>>>> {
>>>>>>>    return H1(P,P) != H(P,P);
>>>>>>> }
>>>>>>>
>>>>>>> Decides that H(P,P) cannot correctly decide the halt status of
>>>>>>> its input,
>>>>>>
>>>>>>
>>>>>> No, it does not. It decides that the results of H1(P, P) doesn't
>>>>>> match the results of H(P, P). It 'decides' that one of these is
>>>>>> correct and the other is not but it cannot tell you which one,
>>>>>> which means it can't decide whether H(P, P) can correctly decide
>>>>>> the halt status of its input.
>>>>>>
>>>>>
>>>>> I simply have not gotten to that part yet.
>>>>
>>>> And yet you claimed to be able to 'decide' that H(P, P) cannot
>>>> correctly decide the halt status of its input. Until you actually
>>>> 'get to that part' you have no business making such a claim.
>>>>
>>>
>>> Odd man out:
>>> When H1(P,P) != H(P,P) we test
>>>    HX(P,P) != H1(P,P)
>>>    HX(P,P) != H(P,P)
>>>
>>> The one that HX(P,P) agrees with is the correct one.
>>
>> There are a potentially infinite number of Hns. Your 'decider' only
>> qualifies as a decider if it works for *every* one of them. Your 'odd
>> man out strategy' only works if the case you are testing happens to be
>> among the three which are included in your test function.
>>
>
> The halting theorem is based on an artificially contrived example that
> would never actually occur in actual practice. In actual practice we
> would only actually need H.

On 9/19/2021 2:22 PM, Andy Walker wrote:
> On 19/09/2021 19:33, olcott wrote:
>> The halting theorem is based on an artificially contrived example
>
>     Not the /theorem/;  one particular proof [of several well-
> known proofs] is based on that, others are not.
>
>> that would never actually occur in actual practice.
>
>     Depends what you mean by "actual practice";  it occurs
> [subject to the caveat in my next paragraph] rather often in
> discussions of the HP, and it occurs [ditto] in almost all C
> programs [just as the sequence 31415926535 occurs in the decimal
> expansion of almost all integers, though rarely in those with
> relatively few digits].
>
>>                               In actual
>> practice we would only actually need H.
>
>     You do realise that the program "H" doesn't actually
> exist?  So it is at least as rare/artificial as "H^".
>

void P(u32 x)
{

if (H(x, x))
HERE: goto HERE;
}

u32 PSR_Olcott_2004(u32 P)
{ return H1(P,P) != H(P,P);
}

int main()
{ Output("Pathological Self-Reference(Olcott 2004) = ",
PSR_Olcott_2004((u32) P));
}

You can't just drop into the middle of a conversation and expect to have
the proper context.

H does exist yet gets the wrong answer as detected by H1 that gets the
right answer.

>> The odd-man-out system does correctly decide an input that was
>> artificially contrived to specifically have the pathological
>> self-reference error (Olcott 2004) for either H or H1. All of the
>> rest of the cases are simply correctly decided by either H or H1.
>
>     No they aren't;  by Rice's theorem if for no other
> reason, assuming that you eventually manage to produce a
> workable definition of "pathological self-reference".
>

I have it fully encoded as the function bodies of H and H1.

--
Copyright 2021 Pete Olcott

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

On 9/19/2021 2:23 PM, André G. Isaak wrote:
> On 2021-09-19 12:33, olcott wrote:
>> On 9/19/2021 1:24 PM, André G. Isaak wrote:
>>> On 2021-09-19 11:54, olcott wrote:
>>>> On 9/19/2021 12:25 PM, André G. Isaak wrote:
>>>>> On 2021-09-19 11:07, olcott wrote:
>>>>>> On 9/19/2021 11:56 AM, André G. Isaak wrote:
>>>>>>> On 2021-09-19 10:39, olcott wrote:
>>>>>>>> On 9/19/2021 11:11 AM, André G. Isaak wrote:
>>>>>>>>> On 2021-09-19 09:46, olcott wrote:
>>>>>>>>>> On 9/19/2021 10:40 AM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-09-19 08:34, olcott wrote:
>>>>>>>>>>>> On 9/18/2021 11:19 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-09-18 22:10, André G. Isaak wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> And note that Rice is talking about properties of Turing
>>>>>>>>>>>>>> Machines (or, more properly, of the language accepted by a
>>>>>>>>>>>>>> TM), not computations.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I realized immediately after hitting 'send' that the above
>>>>>>>>>>>>> will no doubt confuse you since people have been telling
>>>>>>>>>>>>> you that Turing Machines can only express computations
>>>>>>>>>>>>> whereas C/x86 aren't thus constrained.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A computation is a Turing Machine description PLUS an input
>>>>>>>>>>>>> string.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Rice's theorem is concerned with the Turing Machine's
>>>>>>>>>>>>> themselves.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Linz proof shows that you cannot construct a halting
>>>>>>>>>>>>> decider, i.e. a decider which correctly determines for any
>>>>>>>>>>>>> given TM + input string pair, whether that pair represents
>>>>>>>>>>>>> a halting computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Rice's theorem, on the other hand, would rule out the
>>>>>>>>>>>>> construction of something like a Decider Decider, i.e. a TM
>>>>>>>>>>>>> which takes as its input a TM description and determines
>>>>>>>>>>>>> whether that TM qualifies as a decider, i.e. is guaranteed
>>>>>>>>>>>>> to halt on *any* possible input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> André
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Here is where I referred to my code defining a
>>>>>>>>>>>> a decidability decider nine days before you did:
>>>>>>>>>>>
>>>>>>>>>>> Where did I define or even mention a 'decidability decider'?
>>>>>>>>>>> Above I discussed (but did not define) a DECIDER decider,
>>>>>>>>>>> i.e. a TM which determines whether another TM qualifies as a
>>>>>>>>>>> decider.
>>>>>>>>>>>
>>>>>>>>>>>> On 9/9/2021 10:25 AM, olcott wrote:
>>>>>>>>>>>>  > It is the case that H(P,P)==0 is correct
>>>>>>>>>>>>  > It is the case that H1((P,P)==1 is correct
>>>>>>>>>>>>  > It is the case the this is inconsistent.
>>>>>>>>>>>>  > It is the case that this inconsistency
>>>>>>>>>>>>
>>>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>>>  > defines a decidability decider that correctly
>>>>>>>>>>>>
>>>>>>>>>>>>  > rejects P on the basis that P has the
>>>>>>>>>>>>  > pathological self-reference(Olcott 2004) error.
>>>>>>>>>>>
>>>>>>>>>>> So what exactly is it that the above is deciding? And how
>>>>>>>>>>> does this relate to Rice? If you want to claim this is
>>>>>>>>>>> somehow related to rice, you need to identify some semantic
>>>>>>>>>>> property that you claim to be able to decide.
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is deciding that either H/P or H1/P form the pathological
>>>>>>>>>> self-reference error(Olcott 2004). As I said in 2004 this is
>>>>>>>>>> the same error as the Liar Paradox. This means that either H/P
>>>>>>>>>> or H1/P are not correctly decidable.
>>>>>>>>>
>>>>>>>>> The post in which I mentioned a 'decider decider' which you
>>>>>>>>> somehow misread as 'decidability decider' was intended to
>>>>>>>>> clarify a single sentence from an earlier post which you
>>>>>>>>> entirely ignored. Why don't you go back and actually read that
>>>>>>>>> earlier post and address the points made therein.
>>>>>>>>>
>>>>>>>>> Your ill-defined notion of a 'pathological self-reference
>>>>>>>>> error' doesn't appear to be a property of a Turing Machine,
>>>>>>>>> which is what Rice's theorem is concerned with. To the extent
>>>>>>>>> that it is a property at all, it appears to be a property of
>>>>>>>>> specific computations, so this has absolutely no relevance to
>>>>>>>>> Rice.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is the property of H(P,P).
>>>>>>>
>>>>>>> Right, which means this is entirely irrelevant to Rice's theorem.
>>>>>>>
>>>>>>
>>>>>> Many historical posts in comp.theory say otherwise.
>>>>>> If a function can be provided that correctly decides that a
>>>>>> specific TM cannot correctly decide a specific input pair
>>>>>> (according to many historical posts on comp.theory) this does
>>>>>> refute Rice's theorem.
>>>>>
>>>>> So what is the semantic property *of P* that you claim your
>>>>> PSR_Olcott_2004 is capable of identifying?
>>>>>
>>>>> You can't claim that there is anything 'erroneous' about P. There
>>>>> isn't.
>>>>>
>>>>> The fact that you run into a problem when you pass a description of
>>>>> P to some *other* TM is not an indicator that there is something
>>>>> wrong with P. That's like saying that the expression 40 + 50 is
>>>>> 'erroneous' because I can't pass it as an argument to tangent().
>>>>>
>>>>>>>> u32 PSR_Olcott_2004(u32 P)
>>>>>>>> {
>>>>>>>>    return H1(P,P) != H(P,P);
>>>>>>>> }
>>>>>>>>
>>>>>>>> Decides that H(P,P) cannot correctly decide the halt status of
>>>>>>>> its input,
>>>>>>>
>>>>>>>
>>>>>>> No, it does not. It decides that the results of H1(P, P) doesn't
>>>>>>> match the results of H(P, P). It 'decides' that one of these is
>>>>>>> correct and the other is not but it cannot tell you which one,
>>>>>>> which means it can't decide whether H(P, P) can correctly decide
>>>>>>> the halt status of its input.
>>>>>>>
>>>>>>
>>>>>> I simply have not gotten to that part yet.
>>>>>
>>>>> And yet you claimed to be able to 'decide' that H(P, P) cannot
>>>>> correctly decide the halt status of its input. Until you actually
>>>>> 'get to that part' you have no business making such a claim.
>>>>>
>>>>
>>>> Odd man out:
>>>> When H1(P,P) != H(P,P) we test
>>>>    HX(P,P) != H1(P,P)
>>>>    HX(P,P) != H(P,P)
>>>>
>>>> The one that HX(P,P) agrees with is the correct one.
>>>
>>> There are a potentially infinite number of Hns. Your 'decider' only
>>> qualifies as a decider if it works for *every* one of them. Your 'odd
>>> man out strategy' only works if the case you are testing happens to
>>> be among the three which are included in your test function.
>>>
>>
>> The halting theorem is based on an artificially contrived example that
>> would never actually occur in actual practice. In actual practice we
>> would only actually need H.
>
> There is no formal distinction between a Turing Machine and an
> 'artificially contrived' Turing Machine.
>

On 2021-09-19 13:37, olcott wrote:
> On 9/19/2021 2:23 PM, André G. Isaak wrote:

> A set of three Turing machines can defeat the previously undecidable
> inputs. When these machines are fully elaborated such that they can
> handle every combination of conditional branch instructions then we have
> a universal halt decider whenever at least two machines agree.

Which I addressed in the very same post you are responding to, but which
you of course ignored. The relevant portion is preserved below.

You're constructing a Halt Decider X and claiming that it can decide
some H_Hat which was *not* derived from your X, which means it has no
bearing on Linz whatsoever.

>> Using your 'odd man out' approach, you are claiming that neither H,
>> nor H1, nor HX are the actual halt decider, but rather that halting is
>> decided by some larger program that runs each of these and then
>> compares their results. Call that decider UH.
>>
>> One can, using Linz's method, construct a UH_Hat from UH which cannot
>> be decided by UH.

André

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

On 19/09/2021 20:37, olcott wrote:
> A set of three Turing machines can defeat the previously undecidable
> inputs.

There are no "undecidable" inputs. What we have, for any
purported halt decider, is an input that that HD gets wrong. Lots
of other purported HDs get that particular input right [and others
wrong]. As we see below.

> When these machines are fully elaborated such that they can
> handle every combination of conditional branch instructions then we
> have a universal halt decider whenever at least two machines agree.

Your new purported universal HD is as susceptible as the
original PHD to the Linz counter-example, which will now depend on
the new PUHD in the same way that "H^" depended on the original "H".
Note that the original proof shows that there is no correct "H", so
you're wasting your time trying to produce one. But hey!, it's your
time; the rest of us are just amusing ourselves.

--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Dvorak

On 19/09/2021 20:31, olcott wrote:
[I wrote:]
>>      You do realise that the program "H" doesn't actually
>> exist?  So it is at least as rare/artificial as "H^".
> You can't just drop into the middle of a conversation and expect to
> have the proper context.
> H does exist yet gets the wrong answer as detected by H1 that gets
> the right answer.

If your "H" gets the wrong answer, then it is not an "H" as
specified by Linz and other authors. Other programs detecting that
"H" doesn't work do not help your case.

> I have it fully encoded as the function bodies of H and H1.

Where have we heard "I have it fully encoded ..." before?
Produce the actual "H" if you want to be taken seriously.

--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Dvorak

Richard Damon <Richard@Damon-Family.org> writes:

> On 9/18/21 5:54 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly transitions to H.qy.
>>
>> Yet you keep telling us that and "exact copy" of H transitions to the
>> rejecting state when presented with that input of the tape. Identical
>> state transition functions determine the exact same sequence of machine
>> configurations given identical tape contents.
>
> This is Olcotts new double speak.
>
> He has destroyed the meaning of H.

I won't let him. If he writes ⟨Ĥ⟩ he is talking about a Turing machine
(an actual one) that he (confusingly) chooses to call H. The notation
is meaningless in any other context. That TM must have a single
accepting state and a single rejecting state, or the ^ is meaningless.
The <>s relate to some agreed encoding of TMs in the tape alphabet of H
or it's just so much smoke and mirrors.

If he does not mean these things when he writes this notation, he is
being dishonest. And if he does mean these things he keeps making false
statements. I can't know which one is false (H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ |- H.qy or
or Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ |- Ĥ.qn) but they can't both be true.

For the moment I have to assume he is making false statements out of
ignorance. It could be that he is being dishonest and not talking about
Turing machines at all, but he'd have to admit that first.

> I think in the above he actually means that PO-H1 goes to the accepting
> state,

H1 is some junk hidden C code, is it not? I've stopped talking about
his junk hidden C code other than to say he should post it.

The above says that some Turing machine H, with one accepting and one
rejecting state, transitions to its accepting state when presented with
an initial tape containing the agreed encoding of that TM's "hat"
version repeated twice on the tape. If he does not mean that, he should
stop saying it.

--
Ben.

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> On Saturday, 18 September 2021 at 23:55:52 UTC+1, André G. Isaak wrote:
>> On 2021-09-18 16:32, olcott wrote:
>>
>> >
>> > I just defeated Rice's theorem, the other details are for another day.
>> How exactly have you managed to do that?
>>
>> Unless you know which is correct, your H1/H pair are unable to reach a
>> decision at all regarding halting.
>>
> We construct two halt deciders, which are known to be correct, other
> than for "pathological" inputs. When fed such a "pathological" input,
> one returns true and the other returns false.
>
> Therefore using the two halt deciders and selecting the instances where
> they disagree, we have classified the "pathological inputs", something that
> Rice's theorem states that cannot be achieved.

Why do you say that? Surely that depends entirely on the parts you put
in scare quotes. PO (deliberately?) flip-lops between stating that
"pathological" inputs are characterised by a syntactic pattern and by a
semantic property. Why do you even think he knows which one he is
talking about today?

--
Ben.

André G. Isaak <agisaak@gm.invalid> writes:

> On 2021-09-18 17:11, Malcolm McLean wrote:
>> On Saturday, 18 September 2021 at 23:55:52 UTC+1, André G. Isaak wrote:
>>> On 2021-09-18 16:32, olcott wrote:
>>>
>>>>
>>>> I just defeated Rice's theorem, the other details are for another day.
>>> How exactly have you managed to do that?
>>>
>>> Unless you know which is correct, your H1/H pair are unable to reach a
>>> decision at all regarding halting.
>>>
>> We construct two halt deciders, which are known to be correct, other
>> than for "pathological" inputs. When fed such a "pathological" input,
>> one returns true and the other returns false.
>> Therefore using the two halt deciders and selecting the instances where
>> they disagree, we have classified the "pathological inputs", something that
>> Rice's theorem states that cannot be achieved.
>
> How is that a semantic property? "Pathological Inputs" isn't even
> *defined*. It just means something that Olcott doesn't like.

To be fair, he has, on occasion, been clear enough to be wrong about
this. He does sometimes claim that a pathological input is the encoding
of a computation that behaves like <H^><H^> in the sense of being able
to recognise all the possible "hat"-like constructions that could be
applied to H in the proof. With that meaning, even having one of the
magic TMs is contrary to Rice's theorem, so it's not clear why he needs
two. In fact, having such a TM contravenes the halting theorem. He's
often claimed to be building a halt decider based on an algorithm that
is already a halt decider!

But then he also sometimes claims to be simply observing either a static
pattern or a decidable semantic one. Both are possible and two
different such TMs can be constructed but having both does not
contravene Rice's theorem since the combined effect is still not
deciding an "interesting" property.

The flip-flopping is probably not deliberate. Half the time he knows
not what he says.

--
Ben.

olcott <NoOne@NoWhere.com> writes:

> On 9/18/2021 3:46 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
>>>
>>> When the Linz H is a simulating halt decider then the exact Linz
>>> Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does specify recursive simulation.
>> No TM meets Linz's specification for H, so "the Linz H" cannot be a
>> "simulating halt decider".
>
> The Linz conclusion does not apply to a simulating halt decider.

Yes, it does. There is a theorem that says so. There are many
independent proofs of the theorem. You have shown no flaw in any of
those proofs, let alone all of them. You have not even read Linz's
"proper" proof and you refuse to look at others. You don't get to say
you've done it with secret C code you won't post.

--
Ben.

olcott <NoOne@NoWhere.com> writes:

> On 9/18/2021 4:02 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> On 9/18/21 1:04 PM, olcott wrote:
>>>> On 9/18/2021 11:32 AM, Richard Damon wrote:
>>>>> On 9/18/21 12:08 PM, olcott wrote:
>>>>>> On 9/18/2021 10:44 AM, Richard Damon wrote:
>>
>>>>>>> Have you stopped lying about your Halt Decider?
>>>>>>
>>>>>> To the best of my knowledge I have only actually lied once in the last
>>>>>> ten years. I lied to a close friend about a very hurtful truth to
>>>>>> protect them from this very hurtful truth.
>>>>>
>>>>> Since it has been reported that you claimed years ago that you did have
>>>>> a version of your Halt Decider totally coded as a ACTUAL Turing Machine,
>>>>> and you have since retracted that statement, wasn't the first statement
>>>>> a LIE.
>>>>
>>>> Since the key element of the algorithm that correctly decides the halt
>>>> status of the conventional impossible inputs was fully encoded in C and
>>>> code written in C can be applied to Turing machines saying that I had a
>>>> fully encoded Turing machine was poetic license.
>>>
>>> No, it is a LIE. Neither C code nor x86 code is an encoded Turing
>>> Machine, any more than your dog spot is a cat.
>>>
>>> Unless you have a C compiler that can generate Turing Machine Code, you
>>> didn't have an encoded Turing Machine.
>>>
>>>> Now that I know that Turing machine equivalence is a concept that does
>>>> exist I can more accurately refer to my code as Turing equivalent. Even
>>>> when I do this I must augment the common notion of Turing equivalence to
>>>> only apply to the subset of computations that have all the memory that
>>>> they need.
>>>
>>> So you lied out of ignorance, but it is still a lie.
>> He calls it "poetic license", but it was simply a false claim made
>> during a particularly delusional episode. The real dishonest lies were
>> in the cover-up. If you read the exchanges at the time (mid Dec 2018)
>> it is abundantly clear that he was not taking about C code. He really
>> did claim to have what everyone else understands by "an actual Turing
>> machine". Even if we extend his recent defence of "poetic license" to
>> include the term "Universal Turing Machine", we'd have to believe that
>> he intended to write a C-code simulator and that that would take him a
>> couple of weeks!
>> Now I suspect the delusion was that he had a code sketch of something or
>> other that he was certain could be turned into "an actual Turing
>> machine", "fully encoded", "exactly and precisely as in Linz" (his
>> words) but when that hope evaporated, the backpedalling started.
>
> None-the-less I do have fully operational C/x86 code now...

By which you mean "believe me when I say what my secret C code does
despite my previous dishonesty".

--
Ben.