On 8/31/2022 8:04 PM, Richard Damon wrote:
> On 8/31/22 8:54 PM, olcott wrote:
>> On 8/31/2022 7:46 PM, Richard Damon wrote:
>>>
>>> On 8/31/22 8:24 PM, olcott wrote:
>>>> On 8/31/2022 7:14 PM, Richard Damon wrote:
>>>>> On 8/31/22 7:59 PM, olcott wrote:
>>>>>> On 8/31/2022 6:49 PM, Richard Damon wrote:
>>>>>>> On 8/31/22 7:44 PM, olcott wrote:
>>>>>>>> On 8/31/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>> On 8/31/22 10:37 AM, olcott wrote:
>>>>>>>>>> On 8/31/2022 5:58 AM, Richard Damon wrote:
>>>>>>>>>>> On 8/30/22 11:30 PM, olcott wrote:
>>>>>>>>>>>> On 8/30/2022 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/30/22 10:51 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/30/2022 9:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 8/30/22 10:12 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/30/2022 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 8/30/22 9:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/30/2022 8:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/30/22 9:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/30/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 7:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 5:37 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> IF Px REALLY does call Simulate, whether it is
>>>>>>>>>>>>>>>>>>>>>>>>> the simulate you show (which doesn't actually
>>>>>>>>>>>>>>>>>>>>>>>>> simulates, but just calls its input), then Yes,
>>>>>>>>>>>>>>>>>>>>>>>>> THAT Px is Non-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Great an honest reply. Now if H(P,P) was
>>>>>>>>>>>>>>>>>>>>>>>> supposed to predict the behavior of a correct
>>>>>>>>>>>>>>>>>>>>>>>> and complete simulation of its input as if H was
>>>>>>>>>>>>>>>>>>>>>>>> Simulate, then H(P,P) would be correct return
>>>>>>>>>>>>>>>>>>>>>>>> return 0.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You didn't read the rest.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If H is supposed to predict whether or not a pure
>>>>>>>>>>>>>>>>>>>>>> simulation of its input performed by Simulate
>>>>>>>>>>>>>>>>>>>>>> (instead of H) will never stop running and H
>>>>>>>>>>>>>>>>>>>>>> returns 0 then H is necessarily correct no matter
>>>>>>>>>>>>>>>>>>>>>> what process that H uses to make this determination.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But remember, P doesn't call simulate, it calls H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H(P,P) correctly predicts that Simulate(x,y) never
>>>>>>>>>>>>>>>>>>>> halts:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But, assuming we are still talking about the P that
>>>>>>>>>>>>>>>>>>> calls H(P,P), Simulate(P,P) does Halt if H(P,P)
>>>>>>>>>>>>>>>>>>> return 0, so that answer is wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void Simulate(ptr x, ptr y)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If Fred is supposed to determine whether or not
>>>>>>>>>>>>>>>>>> Simulate(Pz, Pz) halts:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> u32 Fred()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Then Fred is necessarily correct*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, H(Pz,Pz) is correct to say 0
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void PP(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(PP, PP));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning 0 means
>>>>>>>>>>>>>>>> that Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> How are you justifying that H(PP,PP) is answering about a
>>>>>>>>>>>>>>> TOTALLY DIFFERENT input Pz,Pz?
>>>>>>>>>>>>>> Every function that returns 0 (interpreted as Boolean) is
>>>>>>>>>>>>>> correctly answering: Does Simulate(Pz,Pz) halt?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If that is the question it is supposed to be answering.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, your trying to claim victory by giving the "right'
>>>>>>>>>>>>> answer to the worng question.
>>>>>>>>>>>>>
>>>>>>>>>>>> I am not done yet.
>>>>>>>>>>>>
>>>>>>>>>>>> *We can move* *ON* *when you agree that this is true*
>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning 0 means that
>>>>>>>>>>>> Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, you are stipulating that H isn't a halt decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am stipulating that H(PP,PP) is a halt decider for
>>>>>>>>>> Simulate(Pz,Pz)
>>>>>>>>>> Thus H(PP,PP)==0 is correct.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> What is Hz? did you mean Pz?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes it was a typo.
>>>>>>>>
>>>>>>>>> And how is it that? Since H hasn't been given anything about
>>>>>>>>> Pz, so how can it be being asked about it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If when I say "there is a black cat sitting on my head" is code
>>>>>>>> for 2 + 3 = 5, then "there is a black cat sitting on my head" is
>>>>>>>> true.
>>>>>>>>
>>>>>>>> In this same way when I say that when H(PP,PP) returns 0 this
>>>>>>>> means that Simulate(Pz,Pz) never halts then H(PP,PP)==0 is correct.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And things based on nonsense are just nonsense.
>>>>>>>
>>>>>>> You misdefine too many things to be allowed to play that game.
>>>>>>>
>>>>>>> FAIL.
>>>>>>>
>>>>>>> Being "Correct" means does what it is supposed to do. Until you
>>>>>>> actually DEFINE how H is "correct" to do this, you are just
>>>>>>> stating non-sense.
>>>>>>>
>>>>>>> Remember, you aren't allowed to stipulate something is correct.
>>>>>>
>>>>>> This is a mandatory prerequisite to the rest of my proof.
>>>>>> I understand if you just want to disagree and don't want to
>>>>>> understand.
>>>>>>
>>>>>
>>>>> If it is a mandatory prerequisite, then your proof is invalid.
>>>>>
>>>>> If you can't explain the GROUNDS that H is using to be ABLE to
>>>>> decide about Simulate(Pz,Pz) when given PP,PP, then your logic is
>>>>> just broken.
>>>>>
>>>>
>>>> Because your only purpose is to be disagreeable I force the cost of
>>>> a continuing dialogue to be mutual agreement at key points in the
>>>> dialogue.
>>>>
>>>> I am unwilling to have any dialogue besides an honest dialogue. An
>>>> honest dialogue require points of mutual agreement.
>>>>
>>>>
>>>
>>> Right, so you need to explain HOW it is possible for H(PP,PP) to be
>>> able to actually decide on Simulate(Pz,Pz).
>>>
>>
>> *We must have have mutual agreement to proceed*
>> *We must have have mutual agreement to proceed*
>> *We must have have mutual agreement to proceed*
>> *We must have have mutual agreement to proceed*
>>
>>
>>
>
> Yes, so answer my questions so we can agree.
>

*We must have have mutual agreement to proceed*
*We must have have mutual agreement to proceed*
*We must have have mutual agreement to proceed*
*We must have have mutual agreement to proceed*

--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer