On 7/27/2021 2:42 PM, André G. Isaak wrote:
> On 2021-07-27 11:31, olcott wrote:
>> On 7/27/2021 12:16 PM, André G. Isaak wrote:
>>> On 2021-07-27 09:24, olcott wrote:
>>>> On 7/27/2021 4:42 AM, Malcolm McLean wrote:
>>>>> On Tuesday, 27 July 2021 at 04:55:26 UTC+1, André G. Isaak wrote:
>>>>>> On 2021-07-26 21:31, olcott wrote:
>>>>>>>
>>>>>>>
>>>>>>> I have explained this totally several times now.
>>>>>>> if H(P,P) != P(P)
>>>>>>> incorrect input
>>>>>>> else
>>>>>>> correct input.
>>>>>> Will you please explain what is meant by H(P,P) != P(P)?
>>>>>>
>>>>>> As written, it mean 'if the result returned by H(P, P) does not equal
>>>>>> the result returned by P(P)', but as I said I *think* by P(P) you
>>>>>> actually mean 'the halting status of P'.
>>>>>>
>>>>>> If that is what you mean then how is H(P,P) != P(P) supposed to be
>>>>>> evaluated *by a Turing Machine*? Rice's Theorem is about what can be
>>>>>> computed, not just about things that can be stated.
>>>>>>
>>>>>> H(P, P) gets P(P) wrong, but it doesn't *know* that it gets this
>>>>>> wrong
>>>>>> (otherwise you'd be able to easily fix H to get it right).
>>>>>>
>>>>> We've had a development. The claim that H(P,P) = false is correct when
>>>>> P(P) halts has been modified.
>>>>> Now we run H on P(P), and run P(P). If they match, then obviously H
>>>>> has
>>>>> done its job. If they don't, then that means that the input is
>>>>> "pathological".
>>>>> The special case suggested by Linz has been detected.
>>>>>
>>>>> There are snags with this approach, of course. For example, if P(P) is
>>>>> non-halting, how would you know when to terminate it?  Ben said that
>>>>> this suggestion always comes up (UCL is a pretty high status
>>>>> university
>>>>> with the UK that attracts intelligent students).
>>>>
>>>> No one has ever gotten as far as I have. No one has ever previously
>>>> shown that the input to a simulating halt decider specifies
>>>> infinitely nested simulation to this halt decider in the HP
>>>> counter-example cases.
>>>>
>>>> Any rebuttals to this assertion require complete citations.
>>>>
>>>> Since no one has ever previously accomplished this key insight this
>>>> makes it impossible that anyone created any software system that
>>>> correctly recognizes and reports this infinitely nested simulation.
>>>>
>>>> When the global simulator reports that the P of int main(){ P(P); }
>>>> halts this is encoded here as P(P)==1
>>>
>>> What exactly is the 'global simulator'?
>>>
>>> You used to have something called a 'global halt decider' but
>>> according to you this *also* wrongly decides that P(P) doesn't halt.
>>>
>>> And in previous posts you've claimed that a 'pure simulation' of P(P)
>>> doesn't halt. Now your saying that it *does* halt inside a 'global
>>> simulator'? So what's the difference between a 'global' simulator and
>>> a 'pure simulator'? Why do you claim it halts in one and not in the
>>> other?
>>>
>>>> When the local partial halt decider H reports that P(P) never halts
>>>> this is encoded here as H(P,P)==0
>>>>
>>>> When they are out-of-sync for inputs with the pathological
>>>> self-reference(Olcott 2004) error we say P(P) != H(P,P)
>>>>
>>>> We will show that this error is exactly the same as the Liar Paradox
>>>> in that both Boolean values are contradicted.
>>>>
>>>> When P(P) != H(P,P) if we change H(P,P)==0 to correspond with P(P)==1
>>>> then the P of int main(){ P(P); } never halts.
>>>
>>> Again, does P(P) != H(P,P) mean that the halting status of P(P)
>>> doesn't match H(P,P),
>>
>> Since I already totally explained this immediately above and your
>
> Not clearly, you didn't. P(P) != H(P, P) is an abuse of notation,
> because you're comparing apples and oranges. This should either mean
> 'the halting status of P(P) doesn't equal the halting status of H(P,P)'

Simulate(P,P)==1 indicates that the global simulator embedded in the
x86utm operating system has determined that the function called by main
has reached its final state.

There will not actually be any function call Simulate(P,P) per say and
this code has not been designed yet.

The very easy part that you should have understood many messages ago is
that when the code somehow determines that the halt decider return value
is not consistent with the behavior of P this is freaking used to
freaking refute Rice.

Yo argued against even considering Rice because you Are stuck in
rebuttal mode. This bias is a form of dishonesty.

> or 'the return value of P(P) doesn't equal the return value of H(P, P)'
> You want it to mean 'the halting status of P(P) doesn't equal the return
> value of H(P, P)'. So I assume that H(P, P) == 0 can mean either H(P, P)
> returns 0, signifying that P(P) doesn't halt, or that H(P, P) itself
> doesn't halt, and that we're just supposed to guess?
>
> So why don't you actually answer the questions I asked. What is a
> 'global simulator' and how can it say that P(P) halts when you've
> previously claimed that in a simulator P(P) doesn't halt?
>
> André
>
>> question is entirely based on your simply not bothering to pay
>> attention this is the only reply that I will make to your reply.
>>
>>> or that the value returned by P(P) does not equal the value returned
>>> by H(P, P)? [The equation means the latter, but I still suspect you
>>> mean the former, but you refuse to clarify].
>>>
>>>> Because P was intentionally defined to do the opposite of whatever
>>>> halt status value that H reports neither Boolean value is correct.
>>>>
>>>> This is exactly the same result as the Liar Paradox.
>>>>
>>>> Because it is true that no P ever halts unless some P is aborted it
>>>> still seems to me that H(P,P)==0 is correct and the fact that the P
>>>> of int main(){ P(P); } halts is the error.
>>>>
>>>> Because no P ever halts unless some P is aborted seems to prove that
>>>> int main(){ P(P); } specifies a non-halting computation.
>>>>
>>>>> The suggestion is to detect
>>>>> the Linz input and special case it.
>>>>>
>>>>
>>>> I don't even have to write any more code. Whenever a human sees that
>>>> H(P,P) reports 0 and the P of int main(){ P(P); } reaches its final
>>>> state we know this is a case of the self-contradictory input
>>>> pathological self-reference(Olcott 2004) error.
>>>
>>> But a human can only recognize this discrepancy in cases where they
>>> can shown that P(P) actually halts despite what H(P, P) does. How do
>>> you get a Turing Machine to do this? That requires a Halt Detector
>>> which is actually always correct to get the real answer to whether
>>> P(P) halts, and currently your Halt Decider gets this wrong. So
>>> you're begging the question here -- the approach requires an
>>> *accurate* universal halt decider, which is exactly the thing you've
>>> been trying, but failing to prove is possible despite the fact that
>>> it is know to be impossible.
>>>
>>> André
>>>
>>>> Applying this same idea to a fully elaborated complete halt decider
>>>> would derive a halt decider where the only time that the input
>>>> reaches a final state and the halt decider reports that this input
>>>> never halts are the self-contradictory input pathological
>>>> self-reference(Olcott 2004) error cases.
>>>>
>>>>
>>>
>>>
>>
>>
>
>

--
Copyright 2021 Pete Olcott

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