On 9/1/2022 6:22 AM, Richard Damon wrote:
>
> 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.
>>
>
> Then H is stipulated to not be a Halt Decider based on your definition
> of this.
>
>> That H must abort the simulation of its input to prevent the infinite
>> execution of this input is another way of saying that this input never
>> stops running.
>>
>>
>
> Nope. Since you are changing the GLOBAL definition H, and not just the
> instance to do your test case, you logic is invalid.
>
> This has been explained to you many times, and you failure to correct
> your statements shows that either you are a pathological liar that
> doesn't care about what is actually true, or you are just totally
> ignorant about the subject, or both (that latter most likely in my case).
>
> The fact that you say this must be true, but when showed the ACTUAL
> BEHAVIOR of that input you still hold to your idea says that you are not
> being honest. The error in your definition is clear because P(P) Halts
> when H(P,P) returns 0, so the fact that some other Hn that who is
> different from this H because it doesn't include the abort, and the Pn
> that is built form that Hn, create an infinite recursion, CAN'T
> correctly define the halting of the P that we have here.
>
> FAIL.
>
> That is like you having a pet snake that you call your pet cat, but when
> someone points out that your pet snake can't be a cat because it doesn't
> have legs and fur, you just reply that not all cats have legs and fur,
> so you are going to keep treating you snake as a cat.

THE MEANING OF THESE WORDS PROVE THAT THEY ARE TRUE

When-so-ever the input/argument to a simulating halt decider (SHD) would
never stop running unless its simulation was aborted is merely another
way of saying that this input never reaches its final state and halts.

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