On 8/31/22 9:08 PM, olcott wrote:
> 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*
>
>

So make the move to reach agreement. MUTUAL agreement isn't one way.