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.

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

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

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

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).
>

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

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

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

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.

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

On 8/31/2022 8:41 PM, Richard Damon wrote:
> 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.

On 8/31/22 9:46 PM, olcott wrote:
> On 8/31/2022 8:41 PM, Richard Damon wrote:
>> 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.
>
> You have not given any objection to the precise words that said and
> there is no correct objection to the precise words that I said because
> they are proven to be true entirely on the basis of their meaning.
>
> Not agreeing with words that are true on the basis of their meaning is a
> sign of dishonesty.
>

On 8/31/2022 10:19 PM, Richard Damon wrote:
> On 8/31/22 9:46 PM, olcott wrote:
>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>> 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.
>>
>> You have not given any objection to the precise words that said and
>> there is no correct objection to the precise words that I said because
>> they are proven to be true entirely on the basis of their meaning.
>>
>> Not agreeing with words that are true on the basis of their meaning is
>> a sign of dishonesty.
>>
>
> No, I have objected to calling something a correct decider when the
> thing it was deciding on was not given in any way as an input.

On 8/31/2022 10:19 PM, Richard Damon wrote:
> On 8/31/22 9:46 PM, olcott wrote:
>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>> 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.
>>
>> You have not given any objection to the precise words that said and
>> there is no correct objection to the precise words that I said because
>> they are proven to be true entirely on the basis of their meaning.
>>
>> Not agreeing with words that are true on the basis of their meaning is
>> a sign of dishonesty.
>>
>
> No, I have objected to calling something a correct decider when the
> thing it was deciding on was not given in any way as an input.
>
The correct behavior of H is stipulated to be correctly determining
whether or not it must abort the simulation of its input to prevent the
otherwise infinite execution of this input.

On 8/31/22 11:43 PM, olcott wrote:
> On 8/31/2022 10:19 PM, Richard Damon wrote:
>> On 8/31/22 9:46 PM, olcott wrote:
>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>>> 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.
>>>
>>> You have not given any objection to the precise words that said and
>>> there is no correct objection to the precise words that I said
>>> because they are proven to be true entirely on the basis of their
>>> meaning.
>>>
>>> Not agreeing with words that are true on the basis of their meaning
>>> is a sign of dishonesty.
>>>
>>
>> No, I have objected to calling something a correct decider when the
>> thing it was deciding on was not given in any way as an input.
>
> You are not going to be able to understand the next step until you
> understand that the prior step is true.
>
> H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts.

On 8/31/22 11:59 PM, olcott wrote:
> On 8/31/2022 10:19 PM, Richard Damon wrote:
>> On 8/31/22 9:46 PM, olcott wrote:
>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>>> 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.
>>>
>>> You have not given any objection to the precise words that said and
>>> there is no correct objection to the precise words that I said
>>> because they are proven to be true entirely on the basis of their
>>> meaning.
>>>
>>> Not agreeing with words that are true on the basis of their meaning
>>> is a sign of dishonesty.
>>>
>>
>> No, I have objected to calling something a correct decider when the
>> thing it was deciding on was not given in any way as an input.
>>
> The correct behavior of H is stipulated to be correctly determining
> whether or not it must abort the simulation of its input to prevent the
> otherwise infinite execution of this input.
>

olcott <polcott2@gmail.com> wrote:

> On 8/31/2022 10:55 AM, Otto J. Makela wrote:
>> olcott <polcott2@gmail.com> wrote:
>>> Input_Halts = 0
>> H(Px,Px) asks the halt decider H() if Px(Px) would stop. Calling
>> Px(Px) would call Simulate(Px,Px) which would call Px(Px) which would
>> again call Simulate(Px,Px) and so on, without ever returning.
>> So yes, in this instance this answer 0 would seem correct.
>> However, this very same case shows that H() does return a value, and
>> H() returning a value of 0 for (all?) cases involving itself would
>> also seem to be incorrect.
>
> It does not show anything like that.
> You are not paying any attention at all.

You mistakenly cut me off mid-sentence, I've restored the context above.
HTH.

That is a strange claim. If H() does NOT return a value, who or what is
printing that line from your output I've quoted above, and where did
that value of zero come from? Would you like to elucidate?

> You are responding with boiler plate to entirely different things that
> I said in the past and are not paying any attention at all to what I
> am actually saying now.

I assure you, I answered your question as directly as I could.
What was the answer you were hoping to see?

--
/* * * Otto J. Makela <om@iki.fi> * * * * * * * * * */
/* Phone: +358 40 765 5772, ICBM: N 60 10' E 24 55' */
/* Mail: Mechelininkatu 26 B 27, FI-00100 Helsinki */
/* * * Computers Rule 01001111 01001011 * * * * * * */

On 8/31/2022 10:55 AM, Otto J. Makela wrote:
> olcott <polcott2@gmail.com> wrote:
>
>> // direct execution of x(y) derives equivalent
>> // behavior to the simulation of x(y)
>> u32 Simulate(ptr x, ptr y)
>> {
>> x(y);
>> return 1;
>> }
>>
>> void Px(ptr x)
>> {
>> Simulate(x, x);
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(Px, Px));
>> }
> [...]
>
>> Input_Halts = 0
>
> H(Px,Px) asks the halt decider H() if Px(Px) would stop. Calling
> Px(Px) would call Simulate(Px,Px) which would call Px(Px) which would
> again call Simulate(Px,Px) and so on, without ever returning.
>
> So yes, in this instance this answer 0 would seem correct.
>
> However, this very same case shows that H() does return a value,

Simulating halt deciders (SHD) such as H continue to simulate their
input until the simulated behavior of their input matches an infinite
behavior pattern then they abort the simulation of this input and return 0.

It is a trivially verified fact that H returns a value. As soon as H
recognizes the infinite behavior pattern H aborts its simulation and
returns 0.

> and
> H() returning a value of 0 for (all?) cases involving itself would
> also seem to be incorrect.
>

In every case where the simulation of the input by H would never stop
running H aborts its simulation and returns 0.

> I really do believe you are here just tickling PD Dr. Gödel from the
> other side: there can not be a halt decider that returns the correct
> answer in all cases.
>
> https://en.wikipedia.org/wiki/Undecidable_problem
>

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

On 9/1/2022 6:14 AM, Richard Damon wrote:
>
> On 8/31/22 11:43 PM, olcott wrote:
>> On 8/31/2022 10:19 PM, Richard Damon wrote:
>>> On 8/31/22 9:46 PM, olcott wrote:
>>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>>>> 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.
>>>>
>>>> You have not given any objection to the precise words that said and
>>>> there is no correct objection to the precise words that I said
>>>> because they are proven to be true entirely on the basis of their
>>>> meaning.
>>>>
>>>> Not agreeing with words that are true on the basis of their meaning
>>>> is a sign of dishonesty.
>>>>
>>>
>>> No, I have objected to calling something a correct decider when the
>>> thing it was deciding on was not given in any way as an input.
>>
>> You are not going to be able to understand the next step until you
>> understand that the prior step is true.
>>
>> H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts.
>
> You can't stipulate something which is illogical or can't exist.
>
When I stipulate "there is a what cat sitting on my head" is code for
the meaning that 2+3=5 then, "there is a what cat sitting on my head" is
true.