On 9/18/2021 5:28 PM, André G. Isaak wrote:
> On 2021-09-18 16:15, olcott wrote:
>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>
>>> Basically (subject to seeing your actual code), you have a machine H
>>> which cannot correctly decide whether P(P) halts but which can
>>> correctly decide whether P1(P1) halts. You also have a machine H1
>>> which can correctly decide whether P(P) halts but which cannot
>>> correctly decide whether P1(P1) halts. So neither of these can
>>> possibly count as a universal halt decider since each has a case it
>>> cannot decide. Neither your H nor your H1 can decide the
>>> corresponding case described by the Linz Proof.
>>>
>>> André
>>>
>>
>> By using the H1/H pair we have a universal halt decider.
>> Whenever they don't provide the same result then one of them is wrong.
>
> And since you have no idea *which* one of them is wrong, how exactly is
> it that you have a 'universal halt decider'?
>
> André
>
>

I just defeated Rice's theorem, the other details are for another day.

--
Copyright 2021 Pete Olcott

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

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 think in the above he actually means that PO-H1 goes to the accepting
state,

Which is fine, since Linz-H^/PO-P was built from PO-H, not PO-H1, so
PO-H1 is allowed to get the answer right, but then he says that PO-H1 is
actually the equivalent of Linz-H even though Linz-H^/PO-P wasn't built
from it, just because it is a copy of the machine that it was built from.

Just showing that PO-H1/H is not a Computation and is disqualified for
the title of Halt Decider.

On 9/18/21 6:29 PM, olcott wrote:
> On 9/18/2021 5:24 PM, Richard Damon wrote:
>> On 9/18/21 6:02 PM, olcott wrote:
>>> On 9/18/2021 4: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.
>>>>
>>>
>>> Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ has the pathological self-reference(Olcott 2004)
>>> error.
>>
>> No such thing in reality. <H^> <H^> is a valid input that H is supposed
>> to get right if it is to be a correct Halt Decider.
>>
>>>
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not have the pathological
>>> self-reference(Olcott 2004) error.
>>
>> But YOUR H isn't the same H as H^ was built from, and thus doesn't apply.
>>
>>>
>>> Computations having the pathological self-reference(Olcott 2004) error
>>> are computationally distinct from ones that do not.
>>
>> So, PO H1 is computationally distinct from PO H, so therefore the P
>> built with PO H isn't built with the same computation that correctly
>> decides it.
>>
>> WORTHLESS. Only the computation that Linz H^ is built from correctly
>> deciding it matters. PO H1 is, from your claim above, NOT that
>> comptation, as PO P is built from PO H which you just said is distinct
>> from PO H1, so it is only PO H that needs to decide PO P correctly,
>> which it does not
>>
>> FAIL,
>>
>>>
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> detects the pathological self-reference(Olcott 2004) error.
>>>
>>> This is made 100% concrete with every detail explicitly shown:
>>>
>>> int main()
>>> {
>>>    if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
>>>      OutputString("Pathological self-reference error!");
>>> }
>>>
>>
>> I.E, you just built a machine to test if your decider is wrong!
>>
>> Which it is.
>>
>
> This defeats Rice's theorem in that it correctly recognizes a semantic
> property of the input.
>
> When the results of a pair of halt deciders H1/H2 are not the same then
> the input has the pathological self-reference(Olcott 2004) error.
>

What is the exact semantic property that you claim this decider detects?

On 2021-09-18 16:32, olcott wrote:
> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>> On 2021-09-18 16:15, olcott wrote:
>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>>
>>>> Basically (subject to seeing your actual code), you have a machine H
>>>> which cannot correctly decide whether P(P) halts but which can
>>>> correctly decide whether P1(P1) halts. You also have a machine H1
>>>> which can correctly decide whether P(P) halts but which cannot
>>>> correctly decide whether P1(P1) halts. So neither of these can
>>>> possibly count as a universal halt decider since each has a case it
>>>> cannot decide. Neither your H nor your H1 can decide the
>>>> corresponding case described by the Linz Proof.
>>>>
>>>> André
>>>>
>>>
>>> By using the H1/H pair we have a universal halt decider.
>>> Whenever they don't provide the same result then one of them is wrong.
>>
>> And since you have no idea *which* one of them is wrong, how exactly
>> is it that you have a 'universal halt decider'?
>>
>> André
>>
>>
>
> 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.

André

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

On 9/18/21 6:55 PM, André G. Isaak wrote:
> On 2021-09-18 16:32, olcott wrote:
>> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>>> On 2021-09-18 16:15, olcott wrote:
>>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>>>
>>>>> Basically (subject to seeing your actual code), you have a machine
>>>>> H which cannot correctly decide whether P(P) halts but which can
>>>>> correctly decide whether P1(P1) halts. You also have a machine H1
>>>>> which can correctly decide whether P(P) halts but which cannot
>>>>> correctly decide whether P1(P1) halts. So neither of these can
>>>>> possibly count as a universal halt decider since each has a case it
>>>>> cannot decide. Neither your H nor your H1 can decide the
>>>>> corresponding case described by the Linz Proof.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> By using the H1/H pair we have a universal halt decider.
>>>> Whenever they don't provide the same result then one of them is wrong.
>>>
>>> And since you have no idea *which* one of them is wrong, how exactly
>>> is it that you have a 'universal halt decider'?
>>>
>>> André
>>>
>>>
>>
>> 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.
>
> André
>
>

I think the issue is he doesn't really know what Rice's theorem is, or
what a semantic property actually is that Rice's theorem is based on.

On 9/18/2021 5:55 PM, André G. Isaak wrote:
> On 2021-09-18 16:32, olcott wrote:
>> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>>> On 2021-09-18 16:15, olcott wrote:
>>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>>>
>>>>> Basically (subject to seeing your actual code), you have a machine
>>>>> H which cannot correctly decide whether P(P) halts but which can
>>>>> correctly decide whether P1(P1) halts. You also have a machine H1
>>>>> which can correctly decide whether P(P) halts but which cannot
>>>>> correctly decide whether P1(P1) halts. So neither of these can
>>>>> possibly count as a universal halt decider since each has a case it
>>>>> cannot decide. Neither your H nor your H1 can decide the
>>>>> corresponding case described by the Linz Proof.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> By using the H1/H pair we have a universal halt decider.
>>>> Whenever they don't provide the same result then one of them is wrong.
>>>
>>> And since you have no idea *which* one of them is wrong, how exactly
>>> is it that you have a 'universal halt decider'?
>>>
>>> André
>>>
>>>
>>
>> I just defeated Rice's theorem, the other details are for another day.
>
> How exactly have you managed to do that?
>

I already told you. I wish you would pay attention.

int main()
{ if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
OutputString("Pathological self-reference error!");
}

> Unless you know which is correct, your H1/H pair are unable to reach a
> decision at all regarding halting.
>
> André
>
>

--
Copyright 2021 Pete Olcott

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

On 9/18/21 6:58 PM, olcott wrote:
> On 9/18/2021 5:55 PM, André G. Isaak wrote:
>> On 2021-09-18 16:32, olcott wrote:
>>> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>>>> On 2021-09-18 16:15, olcott wrote:
>>>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>>>>
>>>>>> Basically (subject to seeing your actual code), you have a machine
>>>>>> H which cannot correctly decide whether P(P) halts but which can
>>>>>> correctly decide whether P1(P1) halts. You also have a machine H1
>>>>>> which can correctly decide whether P(P) halts but which cannot
>>>>>> correctly decide whether P1(P1) halts. So neither of these can
>>>>>> possibly count as a universal halt decider since each has a case
>>>>>> it cannot decide. Neither your H nor your H1 can decide the
>>>>>> corresponding case described by the Linz Proof.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> By using the H1/H pair we have a universal halt decider.
>>>>> Whenever they don't provide the same result then one of them is wrong.
>>>>
>>>> And since you have no idea *which* one of them is wrong, how exactly
>>>> is it that you have a 'universal halt decider'?
>>>>
>>>> André
>>>>
>>>>
>>>
>>> I just defeated Rice's theorem, the other details are for another day.
>>
>> How exactly have you managed to do that?
>>
>
> I already told you. I wish you would pay attention.
>
> int main()
> {
>   if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
>     OutputString("Pathological self-reference error!");
> }
>
>

Which itself proves nothing.

What is the precise Semantic Property that you are deciding on.

Also, Rice's theorem requires a Decider to give the answer, so an if in
main isn't the decider that disproves Rice.

Define your property precisely enough that others can verify it.

Define a decider (maybe call it R) that decides that property on a
machine given to it.

My first guess is that you mean R to be:

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

but now you have to specify what semantic property of P it is detecting.

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.

On 2021-09-18 16:58, olcott wrote:
> On 9/18/2021 5:55 PM, André G. Isaak wrote:
>> On 2021-09-18 16:32, olcott wrote:
>>> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>>>> On 2021-09-18 16:15, olcott wrote:
>>>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>>>>
>>>>>> Basically (subject to seeing your actual code), you have a machine
>>>>>> H which cannot correctly decide whether P(P) halts but which can
>>>>>> correctly decide whether P1(P1) halts. You also have a machine H1
>>>>>> which can correctly decide whether P(P) halts but which cannot
>>>>>> correctly decide whether P1(P1) halts. So neither of these can
>>>>>> possibly count as a universal halt decider since each has a case
>>>>>> it cannot decide. Neither your H nor your H1 can decide the
>>>>>> corresponding case described by the Linz Proof.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> By using the H1/H pair we have a universal halt decider.
>>>>> Whenever they don't provide the same result then one of them is wrong.
>>>>
>>>> And since you have no idea *which* one of them is wrong, how exactly
>>>> is it that you have a 'universal halt decider'?
>>>>
>>>> André
>>>>
>>>>
>>>
>>> I just defeated Rice's theorem, the other details are for another day.
>>
>> How exactly have you managed to do that?
>>
>
> I already told you. I wish you would pay attention.
>
> int main()
> {
>   if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
>     OutputString("Pathological self-reference error!");
> }

And how exactly does that refute Rice? All you're testing is whether
your H and H1 disagree. What does that have to do with Rice or anything
else for that matter?

André

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

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.

André

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

On 9/18/2021 6:11 PM, 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.
>

Bingo !!!

--
Copyright 2021 Pete Olcott

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

On 9/18/21 7:11 PM, 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.
>

But it won't find H2^ which is just as pathological as H^, so it fails,
that could only be detected by testing with H2, another copy of H and H1.

Both H and H1 will get H2^(<H2^>) as correctly halting, but it is
pathological to H2.

On 9/18/21 7:17 PM, olcott wrote:
> On 9/18/2021 6:11 PM, 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.
>>
>
> Bingo !!!
>

See my reply, FAIL-O!

On 9/18/2021 4:32 PM, olcott wrote:
> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>> On 2021-09-18 16:15, olcott wrote:
>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:

>>> By using the H1/H pair we have a universal halt decider.
>>> Whenever they don't provide the same result then one of them is wrong.

Here's my pair:
function H1 (anything) return true;
function H2 (anything) return false;

I too have a universal halt decider! Whenever they don't provide the
same result then one of them is wrong.

I wished I had realized how easy this problem was. I wonder if I'll beat
you to publish.
--
Jeff Barnett

On 19/09/2021 01:21, Jeff Barnett wrote:> On 9/18/2021 4:32 PM, olcott
wrote:
>> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>>> On 2021-09-18 16:15, olcott wrote:
>>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>
>>>> By using the H1/H pair we have a universal halt decider.
>>>> Whenever they don't provide the same result then one of them is wrong.
>
> Here's my pair:
> function H1 (anything) return true;
> function H2 (anything) return false;
>
> I too have a universal halt decider! Whenever they don't provide the
> same result then one of them is wrong.

You could use this to define the PO-semantic property of "horrible
input" (HI). Then you could claim to have defeated Rice as well!
That's like killing two birds with one stone, which is supposedly a
highly admirable achievement. :)

>
> I wished I had realized how easy this problem was. I wonder if I'll beat
> you to publish.

On 9/18/2021 6:09 PM, Richard Damon wrote:
> On 9/18/21 6:58 PM, olcott wrote:
>> On 9/18/2021 5:55 PM, André G. Isaak wrote:
>>> On 2021-09-18 16:32, olcott wrote:
>>>> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>>>>> On 2021-09-18 16:15, olcott wrote:
>>>>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>>>>>
>>>>>>> Basically (subject to seeing your actual code), you have a machine
>>>>>>> H which cannot correctly decide whether P(P) halts but which can
>>>>>>> correctly decide whether P1(P1) halts. You also have a machine H1
>>>>>>> which can correctly decide whether P(P) halts but which cannot
>>>>>>> correctly decide whether P1(P1) halts. So neither of these can
>>>>>>> possibly count as a universal halt decider since each has a case
>>>>>>> it cannot decide. Neither your H nor your H1 can decide the
>>>>>>> corresponding case described by the Linz Proof.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> By using the H1/H pair we have a universal halt decider.
>>>>>> Whenever they don't provide the same result then one of them is wrong.
>>>>>
>>>>> And since you have no idea *which* one of them is wrong, how exactly
>>>>> is it that you have a 'universal halt decider'?
>>>>>
>>>>> André
>>>>>
>>>>>
>>>>
>>>> I just defeated Rice's theorem, the other details are for another day.
>>>
>>> How exactly have you managed to do that?
>>>
>>
>> I already told you. I wish you would pay attention.
>>
>> int main()
>> {
>>   if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
>>     OutputString("Pathological self-reference error!");
>> }
>>
>>
>
> Which itself proves nothing.
>
> What is the precise Semantic Property that you are deciding on.
>
> Also, Rice's theorem requires a Decider to give the answer, so an if in
> main isn't the decider that disproves Rice.
>
> Define your property precisely enough that others can verify it.
>
> Define a decider (maybe call it R) that decides that property on a
> machine given to it.
>
> My first guess is that you mean R to be:
>
> u32 R(u32 P) {
> return H1(P,P) != H(P,P);
> }
>
> but now you have to specify what semantic property of P it is detecting.
>

As I have been saying since at least 2004:
As I have been saying since at least 2004:
As I have been saying since at least 2004:
As I have been saying since at least 2004:

The input has the exact same error as the Liar Paradox

[Halting Problem Final Conclusion]
comp.theory
Peter Olcott
Sep 5, 2004, 11:21:57 AM

The Liar Paradox can be shown to be nothing more than
a incorrectly formed statement because of its pathological
self-reference. The Halting Problem can only exist because
of this same sort of pathological self-reference.
https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ

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));
}

--
Copyright 2021 Pete Olcott

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

On 2021-09-18 21:32, olcott wrote:
> On 9/18/2021 6:09 PM, Richard Damon wrote:
>> On 9/18/21 6:58 PM, olcott wrote:
>>> On 9/18/2021 5:55 PM, André G. Isaak wrote:
>>>> On 2021-09-18 16:32, olcott wrote:
>>>>> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>>>>>> On 2021-09-18 16:15, olcott wrote:
>>>>>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>> Basically (subject to seeing your actual code), you have a machine
>>>>>>>> H which cannot correctly decide whether P(P) halts but which can
>>>>>>>> correctly decide whether P1(P1) halts. You also have a machine H1
>>>>>>>> which can correctly decide whether P(P) halts but which cannot
>>>>>>>> correctly decide whether P1(P1) halts. So neither of these can
>>>>>>>> possibly count as a universal halt decider since each has a case
>>>>>>>> it cannot decide. Neither your H nor your H1 can decide the
>>>>>>>> corresponding case described by the Linz Proof.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> By using the H1/H pair we have a universal halt decider.
>>>>>>> Whenever they don't provide the same result then one of them is
>>>>>>> wrong.
>>>>>>
>>>>>> And since you have no idea *which* one of them is wrong, how exactly
>>>>>> is it that you have a 'universal halt decider'?
>>>>>>
>>>>>> André
>>>>>>
>>>>>>
>>>>>
>>>>> I just defeated Rice's theorem, the other details are for another day.
>>>>
>>>> How exactly have you managed to do that?
>>>>
>>>
>>> I already told you. I wish you would pay attention.
>>>
>>> int main()
>>> {
>>>    if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
>>>      OutputString("Pathological self-reference error!");
>>> }
>>>
>>>
>>
>> Which itself proves nothing.
>>
>> What is the precise Semantic Property that you are deciding on.
>>
>> Also, Rice's theorem requires a Decider to give the answer, so an if in
>> main isn't the decider that disproves Rice.
>>
>> Define your property precisely enough that others can verify it.
>>
>> Define a decider (maybe call it R) that decides that property on a
>> machine given to it.
>>
>> My first guess is that you mean R to be:
>>
>> u32 R(u32 P) {
>>     return H1(P,P) != H(P,P);
>> }
>>
>> but now you have to specify what semantic property of P it is detecting.
>
> As I have been saying since at least 2004:
> As I have been saying since at least 2004:
> As I have been saying since at least 2004:
> As I have been saying since at least 2004:

No one cares how long you have been saying something. Nothing you write
below is remotely relevant to Richard's question. Which semantic
property do you claim to be able to decide?

You don't mention a single semantic property in your ramblings below.

If you want to claim that your ill-defined notion of 'pathological
self-reference' is a semantic property, you need to actually give it a
rigorous formal definition.

If you can both define this property and demonstrate that it is actually
a *semantic* property, then to refute Rice you would need to create some
sort of decider which can correctly decide whether *any* arbitrary
Turing Machine has this property. Just claiming you have something which
decides it for one specific instance would not constitute a refutation
of Rice.

And note that Rice is talking about properties of Turing Machines (or,
more properly, of the language accepted by a TM), not computations.

This means need some decider X which takes as its input the description
of a Turing Machine (not a computation) and determines whether that TM
has the property in question.

Your 'pathological self-reference', to the extent that it is a property
at all, isn't a property of a Turing Machine since your P apparently
involves pathological self-reference when it is given as an input to H,
but *not* when it is run independently or given as an input to H1. So
does P have this mysterious property or not? The decider would be given
only a description of P as its input. It would not be told what the
input string given to P is, and it certainly wouldn't be told whether P
is being run independently, whether it is being given as an input to H
or whether it is being given as an input to H1.

André

> The input has the exact same error as the Liar Paradox
>
> [Halting Problem Final Conclusion]
> comp.theory
> Peter Olcott
> Sep 5, 2004, 11:21:57 AM
>
> The Liar Paradox can be shown to be nothing more than
> a incorrectly formed statement because of its pathological
> self-reference. The Halting Problem can only exist because
> of this same sort of pathological self-reference.
> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>
> 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));
> }
>
>

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

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é

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

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

Bingo! I have said it this same way recently.

// Decidability Decider
u32 PSR_Olcott_2004(u32 P)
{ return H1(P,P) == H(P,P);
}

--
Copyright 2021 Pete Olcott

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

On 2021-09-18 23:12, 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é
>>
>
> Bingo! I have said it this same way recently.

No, you have not.

> // Decidability Decider
> u32 PSR_Olcott_2004(u32 P)
> {
>   return H1(P,P) == H(P,P);
> }

And how is the above related to anything I wrote in my original post or
in the post clarifying that post to which you are responding? You don't
answer the actual question which was asked (i.e. which semantic property
do you claim to be able to decide using the above?) nor do you show even
the remotest evidence of having even read my post.

André

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

On 9/19/21 1:12 AM, 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é
>>
>
> Bingo! I have said it this same way recently.
>
> // Decidability Decider
> u32 PSR_Olcott_2004(u32 P)
> {
>   return H1(P,P) == H(P,P);
> }
>
>

And WHAT exactly is the property YOU are defining as a decidability decider?

Why does this get H2^ wrong (The Linz machine made from a different copy
of H, H2)? Your above will call this machine Decidable.

On 9/18/21 11:32 PM, olcott wrote:
> On 9/18/2021 6:09 PM, Richard Damon wrote:
>> On 9/18/21 6:58 PM, olcott wrote:
>>> On 9/18/2021 5:55 PM, André G. Isaak wrote:
>>>> On 2021-09-18 16:32, olcott wrote:
>>>>> On 9/18/2021 5:28 PM, André G. Isaak wrote:
>>>>>> On 2021-09-18 16:15, olcott wrote:
>>>>>>> On 9/18/2021 5:08 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>> Basically (subject to seeing your actual code), you have a machine
>>>>>>>> H which cannot correctly decide whether P(P) halts but which can
>>>>>>>> correctly decide whether P1(P1) halts. You also have a machine H1
>>>>>>>> which can correctly decide whether P(P) halts but which cannot
>>>>>>>> correctly decide whether P1(P1) halts. So neither of these can
>>>>>>>> possibly count as a universal halt decider since each has a case
>>>>>>>> it cannot decide. Neither your H nor your H1 can decide the
>>>>>>>> corresponding case described by the Linz Proof.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> By using the H1/H pair we have a universal halt decider.
>>>>>>> Whenever they don't provide the same result then one of them is
>>>>>>> wrong.
>>>>>>
>>>>>> And since you have no idea *which* one of them is wrong, how exactly
>>>>>> is it that you have a 'universal halt decider'?
>>>>>>
>>>>>> André
>>>>>>
>>>>>>
>>>>>
>>>>> I just defeated Rice's theorem, the other details are for another day.
>>>>
>>>> How exactly have you managed to do that?
>>>>
>>>
>>> I already told you. I wish you would pay attention.
>>>
>>> int main()
>>> {
>>>    if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
>>>      OutputString("Pathological self-reference error!");
>>> }
>>>
>>>
>>
>> Which itself proves nothing.
>>
>> What is the precise Semantic Property that you are deciding on.
>>
>> Also, Rice's theorem requires a Decider to give the answer, so an if in
>> main isn't the decider that disproves Rice.
>>
>> Define your property precisely enough that others can verify it.
>>
>> Define a decider (maybe call it R) that decides that property on a
>> machine given to it.
>>
>> My first guess is that you mean R to be:
>>
>> u32 R(u32 P) {
>>     return H1(P,P) != H(P,P);
>> }
>>
>> but now you have to specify what semantic property of P it is detecting.
>>
>
> As I have been saying since at least 2004:
> As I have been saying since at least 2004:
> As I have been saying since at least 2004:
> As I have been saying since at least 2004:
>
> The input has the exact same error as the Liar Paradox

No, it does NOT.

The input is a description of a Turing Machine (or is if H is a Turing
Machine)

ALL Turing Machines will either Halt or be Non-Halting, so there IS a
proper answer for every machine.

The problem is you are asking the wrong question.

The question that H needs to answer is does the machine H^ Halt, and
since you algorithm for H says H^ is non-halting, H^ will Halt.

The problem that is like the equivalent to the Liar's Paradox is the
DESIGN question for H, what can H do to get this one question right, and
that IS the equivalent to the Liar's Paradox, but that doesn't prove
that the input is malformed, as the input doesn't exist yet, it shows
that an H that 'beat' Linz ^ machine doesn't exist.

You error seems to be an implied assumption that all problems must have
a solution. They don't.

>
> [Halting Problem Final Conclusion]
> comp.theory
> Peter Olcott
> Sep 5, 2004, 11:21:57 AM
>
> The Liar Paradox can be shown to be nothing more than
> a incorrectly formed statement because of its pathological
> self-reference. The Halting Problem can only exist because
> of this same sort of pathological self-reference.
> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>
> 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));
> }
>
>

On 9/19/2021 1:00 AM, André G. Isaak wrote:
> On 2021-09-18 23:12, 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é
>>>
>>
>> Bingo! I have said it this same way recently.
>
> No, you have not.

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 rejects P on
> the basis that P has the
> pathological self-reference(Olcott 2004) error.

> decidability decider that correctly rejects P on
> the basis that P has the
> pathological self-reference(Olcott 2004) error.

> decidability decider that correctly rejects P on
> the basis that P has the
> pathological self-reference(Olcott 2004) error.

>
>> // Decidability Decider
>> u32 PSR_Olcott_2004(u32 P)
>> {
>>    return H1(P,P) == H(P,P);
>> }
>
> And how is the above related to anything I wrote in my original post or
> in the post clarifying that post to which you are responding? You don't
> answer the actual question which was asked (i.e. which semantic property
> do you claim to be able to decide using the above?) nor do you show even
> the remotest evidence of having even read my post.
>
> André
>

--
Copyright 2021 Pete Olcott

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

On 2021-09-19 05:56, olcott wrote:
> On 9/19/2021 1:00 AM, André G. Isaak wrote:
>> On 2021-09-18 23:12, 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é
>>>>
>>>
>>> Bingo! I have said it this same way recently.
>>
>> No, you have not.

How does anything you write below resemble what I wrote above? You claim
to have said something 'this same way', but what you have below isn't
remotely related to what I wrote above.

André

>
> 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 rejects P on
> > the basis that P has the
> > pathological self-reference(Olcott 2004) error.
>
> > decidability decider that correctly rejects P on
> > the basis that P has the
> > pathological self-reference(Olcott 2004) error.
>
> > decidability decider that correctly rejects P on
> > the basis that P has the
> > pathological self-reference(Olcott 2004) error.
>
>>
>>> // Decidability Decider
>>> u32 PSR_Olcott_2004(u32 P)
>>> {
>>>    return H1(P,P) == H(P,P);
>>> }
>>
>> And how is the above related to anything I wrote in my original post
>> or in the post clarifying that post to which you are responding? You
>> don't answer the actual question which was asked (i.e. which semantic
>> property do you claim to be able to decide using the above?) nor do
>> you show even the remotest evidence of having even read my post.
>>
>> André
>>
>
>

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

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:

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.

--
Copyright 2021 Pete Olcott

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