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.

--
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 Tue, 30 Aug 2022 21:12:24 -0500
olcott <polcott2@gmail.com> 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.

Called it.

/Flibble

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?

H(PP,PP) needs to answer about Simuate(PP,PP) not Simulate(Pz,Pz)

H needs to answer about its ACTUAL INPUT, not something that wasn't
given as its input.

Hasn't that been your mantra for tha last years?

PP != Pz, so H can't answer about its non-input.

On 8/30/22 10:21 PM, Mr Flibble wrote:
> On Tue, 30 Aug 2022 21:12:24 -0500
> olcott <polcott2@gmail.com> 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.
>
> Called it.
>
> /Flibble
>

Yep, it was clear what his scam was going to be, but it is totally
unjustifed, so he has painted himself as a outright idiot.

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?
>
What I said is proven to be completely true entirely on the basis of the
meaning of its words. *Agree to this and we can go on to the next step*

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

--
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 8/30/22 10:46 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?
>>
> What I said is proven to be completely true entirely on the basis of the
> meaning of its words. *Agree to this and we can go on to the next step*
>
>
>

How is H(PP,PP) being asked about Simulate(Pz,Pz)? (When Pz is not PP)

Please give the EXACT MEANING of the words that you are using to claim this?

Remember, you are STARTING from the definition of H being a Halting
Decider, and thus

H(P,d) returns 1 if P(d) or equivalently UTM(P,d) Halts, and
H(P,d) returns 0 if P(d) or equivalently UTM(P,d) will Never Halt.

No where is there this other Pz machine mentioned at all.

You Bluff is called.

Lay out your cards or be proved to be a LIAR or an IDIOT.

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.

That is EXACTLY the case of being asked what is 2+3 and you saying 7,
because that is what 3+4 is, so you were right about 3+4.

You are still wrong about the question it is supposed to be answering,
and proven to be just a pathological liar bent on being decietful.

So, I guess you are just admitting that for the past 18 years you
haven't been working on the Halting problem but something else.

YOU ARE A TOTAL FAILURE.

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

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

--
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 8/30/22 11:25 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 one 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.
>
>

No, because returning 0 from H(PP,PP) does NOT MEAN that Simulate(Pz,Pz)
never stops, it means the Simulate(PP,PP) will not stop.

Unless yolu RECANT that you will ever claim that H is a Halt Decider,
you are just showing yourself to be a deciver.

You have LIED too many times about what you claim.

Therefore, unless you explicitly renounce your previous claims about
what something means, that previous meaning is in effect.

So, unless you include a statement that for THIS STATEMENT, H is NOT
what you will claim to be a Halt Decider, you can't change what its
output means.

You seem to not understand that things ACTUALLY DO HAVE MEANINGS, and
they can't just be changed at your whim.

The fact that H might accidentally give the right answer, doesn't make
it correct in its answer.

A decider is either correct or it is incorrect, it is incorrect if it
gets ONE answer wrong. A given answer might "match" the desire, so
perhaps you can say that answer was correct, but the decider was not
correct.

FAIL.

You are caught in the act of trying to be deciptive.

This was even pointed out be several people BEFORE you did it, which
shows how bad you are at trying to be decietful.

YOU ARE JUST A FAILURE.

On 8/30/2022 10:36 PM, Richard Damon wrote:
>
> On 8/30/22 11:25 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 one 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.
>>
>>
>
> No, because returning 0 from H(PP,PP) does NOT MEAN that Simulate(Pz,Pz)
> never stops, it means the Simulate(PP,PP) will not stop.
>

When we stipulate that it means this then H(PP,PP)==0 is correct.
*We can't move on to the next step until after you get this*

--
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 8/31/22 12:10 AM, olcott wrote:
> On 8/30/2022 10:36 PM, Richard Damon wrote:
>>
>> On 8/30/22 11:25 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 one 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.
>>>
>>>
>>
>> No, because returning 0 from H(PP,PP) does NOT MEAN that
>> Simulate(Pz,Pz) never stops, it means the Simulate(PP,PP) will not stop.
>>
>
> When we stipulate that it means this then H(PP,PP)==0 is correct.
> *We can't move on to the next step until after you get this*
>

So, you are stipulating that H isn't a halt decider.

Remember, you can't stipulate something to be "correct", on;y what a
word means, so you stiulation is that H isn't a Halt Decider, but some
crasy Olcott Fantasy Function.

Yes, if the Problem H is solving is the Halting of a transformed
machine, and thus BY DEFINITION, not the Halting of the ACTUAL INPUT. We
can call this property POOP (for Peter Olcotts Other Problem).

THus H can be a Correct POOP decider answering H(PP,PP) as 0 since
Simulate(Pz, Pz) Halts.

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.

Remember, you can't stipulate something to be "correct", on;y what a
word means, so you stiulation is that H isn't a Halt Decider, but some
crasy Olcott Fantasy Function.

Yes, if the Problem H is solving is the Halting of a transformed
machine, and thus BY DEFINITION, not the Halting of the ACTUAL INPUT. We
can call this property POOP (for Peter Olcotts Other Problem).

THus H can be a Correct POOP decider answering H(PP,PP) as 0 since
Simulate(Pz, Pz) Halts.

On 8/31/2022 5:57 AM, Richard Damon wrote:
> On 8/31/22 12:10 AM, olcott wrote:
>> On 8/30/2022 10:36 PM, Richard Damon wrote:
>>>
>>> On 8/30/22 11:25 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 one 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.
>>>>
>>>>
>>>
>>> No, because returning 0 from H(PP,PP) does NOT MEAN that
>>> Simulate(Pz,Pz) never stops, it means the Simulate(PP,PP) will not stop.
>>>
>>
>> When we stipulate that it means this then H(PP,PP)==0 is correct.
>> *We can't move on to the next step until after you get this*
>>
>
> So, you are stipulating that H isn't a halt decider.
H(PP,PP) <is> stipulated to be a halt decider for Simulate(Pz,Pz), thus
H(PP,PP)==0 means that Simulate(Pz,Pz) doesn't halt.

*Until you agree that H(PP,PP) ==0 is correct on this basis*
*we cannot move on to the next step*

--
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 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(Hz,Hz)
Thus H(PP,PP)==0 is correct.

--
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 Wed, 31 Aug 2022 09:34:15 -0500
olcott <polcott2@gmail.com> wrote:

> On 8/31/2022 5:57 AM, Richard Damon wrote:
> > On 8/31/22 12:10 AM, olcott wrote:
> >> On 8/30/2022 10:36 PM, Richard Damon wrote:
> >>>
> >>> On 8/30/22 11:25 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 one 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.
> >>>>
> >>>>
> >>>
> >>> No, because returning 0 from H(PP,PP) does NOT MEAN that
> >>> Simulate(Pz,Pz) never stops, it means the Simulate(PP,PP) will
> >>> not stop.
> >>
> >> When we stipulate that it means this then H(PP,PP)==0 is correct.
> >> *We can't move on to the next step until after you get this*
> >>
> >
> > So, you are stipulating that H isn't a halt decider.
> H(PP,PP) <is> stipulated to be a halt decider for Simulate(Pz,Pz),
> thus H(PP,PP)==0 means that Simulate(Pz,Pz) doesn't halt.
>
> *Until you agree that H(PP,PP) ==0 is correct on this basis*
> *we cannot move on to the next step*

You only seem able to play one tune and that tune is becoming extremely
tiresome.

/Flibble

On 8/31/2022 10:33 AM, Mr Flibble wrote:
> On Wed, 31 Aug 2022 09:34:15 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 8/31/2022 5:57 AM, Richard Damon wrote:
>>> On 8/31/22 12:10 AM, olcott wrote:
>>>> On 8/30/2022 10:36 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/30/22 11:25 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 one 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.
>>>>>>
>>>>>>
>>>>>
>>>>> No, because returning 0 from H(PP,PP) does NOT MEAN that
>>>>> Simulate(Pz,Pz) never stops, it means the Simulate(PP,PP) will
>>>>> not stop.
>>>>
>>>> When we stipulate that it means this then H(PP,PP)==0 is correct.
>>>> *We can't move on to the next step until after you get this*
>>>>
>>>
>>> So, you are stipulating that H isn't a halt decider.
>> H(PP,PP) <is> stipulated to be a halt decider for Simulate(Pz,Pz),
>> thus H(PP,PP)==0 means that Simulate(Pz,Pz) doesn't halt.
>>
>> *Until you agree that H(PP,PP) ==0 is correct on this basis*
>> *we cannot move on to the next step*
>
> You only seem able to play one tune and that tune is becoming extremely
> tiresome.
>
> /Flibble

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, and
H() returning a value of 0 for (all?) cases involving itself would
also seem to be incorrect.

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

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

It does not show anything like that.
You are not paying any attention at all.

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.

--
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 8/31/22 10:34 AM, olcott wrote:
> On 8/31/2022 5:57 AM, Richard Damon wrote:
>> On 8/31/22 12:10 AM, olcott wrote:
>>> On 8/30/2022 10:36 PM, Richard Damon wrote:
>>>>
>>>> On 8/30/22 11:25 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 one 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.
>>>>>
>>>>>
>>>>
>>>> No, because returning 0 from H(PP,PP) does NOT MEAN that
>>>> Simulate(Pz,Pz) never stops, it means the Simulate(PP,PP) will not
>>>> stop.
>>>>
>>>
>>> When we stipulate that it means this then H(PP,PP)==0 is correct.
>>> *We can't move on to the next step until after you get this*
>>>
>>
>> So, you are stipulating that H isn't a halt decider.
> H(PP,PP) <is> stipulated to be a halt decider for Simulate(Pz,Pz), thus
> H(PP,PP)==0 means that Simulate(Pz,Pz) doesn't halt.
>
> *Until you agree that H(PP,PP) ==0 is correct on this basis*
> *we cannot move on to the next step*
>

But why is H given PP instead of Pz as a parameter.

The problem is you have used up you benefit of the doubt, so when you
make a streached claim, you need to meke the required disclaimers.

Halt Decider are BY DEFINITON supposed to be give a description of the
machine theh are deciding on.

In you example, H is being given a description of PP, but you claim it
is being asked about Pz.

This is illogical, and a viplation of the definition.

Unless you EXPLICITILY disclaim that H is trying to be a decider of the
Program PP(PP), and thus can't be deciding the "Impossible Program", you
are just going to get the respose that you are presenting a Red Herring.

On 8/31/22 11:38 AM, olcott wrote:
> On 8/31/2022 10:33 AM, Mr Flibble wrote:
>> On Wed, 31 Aug 2022 09:34:15 -0500
>> olcott <polcott2@gmail.com> wrote:
>>
>>> On 8/31/2022 5:57 AM, Richard Damon wrote:
>>>> On 8/31/22 12:10 AM, olcott wrote:
>>>>> On 8/30/2022 10:36 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 8/30/22 11:25 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 one 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.
>>>>>>>
>>>>>>
>>>>>> No, because returning 0 from H(PP,PP) does NOT MEAN that
>>>>>> Simulate(Pz,Pz) never stops, it means the Simulate(PP,PP) will
>>>>>> not stop.
>>>>>
>>>>> When we stipulate that it means this then H(PP,PP)==0 is correct.
>>>>> *We can't move on to the next step until after you get this*
>>>>
>>>> So, you are stipulating that H isn't a halt decider.
>>> H(PP,PP) <is> stipulated to be a halt decider for Simulate(Pz,Pz),
>>> thus H(PP,PP)==0 means that Simulate(Pz,Pz) doesn't halt.
>>>
>>> *Until you agree that H(PP,PP) ==0 is correct on this basis*
>>> *we cannot move on to the next step*
>>
>> You only seem able to play one tune and that tune is becoming extremely
>> tiresome.
>>
>> /Flibble
>
>
> It is the only way for me to prevent the strawman deception fake
> rebuttals of my work. The fake rebuttals are very convincing to the
> gullible and ignorant.
>
>
>

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(Hz,Hz)
> Thus H(PP,PP)==0 is correct.
>

What is Hz? did you mean Pz?

And how is it that? Since H hasn't been given anything about Pz, so how
can it be being asked about it.

Halt Deciders must be given a description of the input they are to
decide on. since PP isn't a description of Pz, you stipulation is INVALID.

You can't stipulate an impossibility.

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.

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