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.

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