On 8/31/22 9:29 PM, olcott wrote:
> On 8/31/2022 8:16 PM, Richard Damon wrote:
>> 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.
>
> *You must agree with my point or I will not move on to the next point*
>
>

Nope, I've given my objection, and until you answer it, I will not move on.

I have time, how much do you?