On 9/20/22 7:17 PM, olcott wrote:
> On 9/20/2022 5:39 PM, Richard Damon wrote:
>>
>> On 9/20/22 9:55 AM, olcott wrote:
>>> On 9/20/2022 6:03 AM, Richard Damon wrote:
>>>> On 9/19/22 11:56 PM, olcott wrote:
>>>>> On 9/19/2022 10:46 PM, Richard Damon wrote:
>>>>>> On 9/19/22 11:39 PM, olcott wrote:
>>>>>>> On 9/19/2022 10:32 PM, Richard Damon wrote:
>>>>>>>> On 9/19/22 11:19 PM, olcott wrote:
>>>>>>>>> On 9/19/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/19/22 10:12 PM, olcott wrote:
>>>>>>>>>>> On 9/19/2022 8:24 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/19/22 8:59 PM, olcott wrote:
>>>>>>>>>>>>> On 9/19/2022 7:52 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/19/22 8:15 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/19/2022 6:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/19/22 6:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/19/2022 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/19/22 11:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/19/2022 5:55 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/18/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 9:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports its direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it doesn't. It is only correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *IF* its input wouldn't halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  > If Hx DOES directly execute its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input, then it will NEVER report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  > non-halting, and yes, then the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px built from THAT Hx will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And since Hx doesn't directly execute
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Its basis for correctly deciding that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of this input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt is a wild guess.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, it guesses wrong about the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question that is being asked of it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why do I have to tell you the same thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 500 times and you still don't get it?  My
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theory is that you are a liar only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> interested in rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No halt decider ever directly executes its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input yet must correctly predict the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of this directly executed or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, THE behavior of direct execution or
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation, not by the decider, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>> just done.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you want to add the words "by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider", you need a source for that, which
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have failed to do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> First you must agree that every Hx returning
>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 does correctly report the halt status of
>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of what its direct execution of
>>>>>>>>>>>>>>>>>>>>>>>>>>> Px(Px) would be if it directly executed this
>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No. because no Hx that does a direct execution
>>>>>>>>>>>>>>>>>>>>>>>>>> even gives an answer, so your statement is
>>>>>>>>>>>>>>>>>>>>>>>>>> ILLOGICAL.
>>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders are not supposed to do a direct
>>>>>>>>>>>>>>>>>>>>>>>>> execution and you know this so what the Hell
>>>>>>>>>>>>>>>>>>>>>>>>> are you trying to pull here?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Right, the aren't supposed to so why do you
>>>>>>>>>>>>>>>>>>>>>>>> think they need to act like they did?
>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must correctly predict what the
>>>>>>>>>>>>>>>>>>>>>>> behavior of their directly executed or correctly
>>>>>>>>>>>>>>>>>>>>>>> simulated input would be Hx(Px,Px)==0 does that.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Why do you say that?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You have already agreed that if main calls P(P),
>>>>>>>>>>>>>>>>>>>>>> and H(P,P) returns 0 that P(P) will return in
>>>>>>>>>>>>>>>>>>>>>> finite time, so the "directly executed input" of
>>>>>>>>>>>>>>>>>>>>>> H(P,P) is shown to be Halting in this case.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The only correct invocation of P(P) that must
>>>>>>>>>>>>>>>>>>>>> considered is the invocation by H. As I have been
>>>>>>>>>>>>>>>>>>>>> always saying the other one is irrelevant.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> int H(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This instance of P never halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, wrong terminology.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That VERSION of P never halts, and that version of H
>>>>>>>>>>>>>>>>>>>> never gives an answer, so is wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *A halt decider always only predicts the behavior of
>>>>>>>>>>>>>>>>>>> its input*, the above behavior is what Hx must
>>>>>>>>>>>>>>>>>>> predict. By using an adapted version of the infinite
>>>>>>>>>>>>>>>>>>> recursion behavior pattern a simulating halt decider
>>>>>>>>>>>>>>>>>>> does correctly predict the above behavior in a finite
>>>>>>>>>>>>>>>>>>> number of steps and as a pure function of its inputs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, just shows you don't know what you are talking
>>>>>>>>>>>>>>>>>> about.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All of your reasoning has been of the form that the
>>>>>>>>>>>>>>>>> halt decider must execute its non-halting input and
>>>>>>>>>>>>>>>>> then report on its behavior after its infinite
>>>>>>>>>>>>>>>>> execution (never) completes.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, it doesn't have to execute its non-halting input,
>>>>>>>>>>>>>>>> it need to recognize IF its input is non-halting without
>>>>>>>>>>>>>>>> actually executing it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then all of the times that you said the problem with my
>>>>>>>>>>>>>>> halt decider is that it didn't execute its input you knew
>>>>>>>>>>>>>>> that you were lying.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When did I say H needed to execute its input?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I've said that its answer needs to be based on the
>>>>>>>>>>>>>> behavior of just executing the input, return 1 if an
>>>>>>>>>>>>>> execution of the input would halt, and 0 if t wouldn't.
>>>>>>>>>>>>> Thus the Hx halt status decision must be based on the
>>>>>>>>>>>>> behavior of just executing the H(P,P) input:
>>>>>>>>>>>>>
>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Next you will say that although:
>>>>>>>>>>>>> "its answer needs to be based on the behavior of just
>>>>>>>>>>>>> executing the input"
>>>>>>>>>>>>>
>>>>>>>>>>>>> You don't really mean:
>>>>>>>>>>>>> "its answer needs to be based on the behavior of just
>>>>>>>>>>>>> executing the input"
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, you can't show where I said what you claim I said, so
>>>>>>>>>>>> you are just admitting you are lying.
>>>>>>>>>>>>
>>>>>>>>>>>> You don't seem to understand that we can have independent
>>>>>>>>>>>> execution of things
>>>>>>>>>>>
>>>>>>>>>>> When we have independent execution of a dependent computation
>>>>>>>>>>> we get an incorrect measure of the actual behavior, likewise
>>>>>>>>>>> with the reverse.
>>>>>>>>>>
>>>>>>>>>> What is the "dependent computation" that is giving you a problem?
>>>>>>>>>>
>>>>>>>>> The halting value of P depends on the return value from H or
>>>>>>>>> not depending on where P is executed. This changes the behavior
>>>>>>>>> of P
>>>>>>>>> depending on where P is executed.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, the Halting Value of P depends on the return value from H,
>>>>>>>> ALWAYS.
>>>>>>>>
>>>>>>> By the same reasoning a computer program that is never executed
>>>>>>> must still produce results.
>>>>>>>
>>>>>>
>>>>>> No, but a computer program that is never executed will still have
>>>>>> a defined a result if it was run.
>>>>>
>>>>> H aborts its simulation of P before P invokes H. The halt criteria
>>>>> is best understood as the infinite recursion behavior pattern. Once
>>>>> this is understood then the infinite simulation adaptation can be
>>>>> understood.
>>>>>
>>>>>
>>>>
>>>> Yes, but the behavior we are looking at is NOT the results of the
>>>> PARTIAL simulation that H does, but either the COMPLETE simulation
>>>> of P or the direct execution of P.
>>>
>>> So you are back to saying that the only correct halt decider is a
>>> halt decider that never returns because it is stuck in infinite
>>> recursion or infinite simulation.
>>>
>>>
>>
>> Where did I say that?
>
> On 9/20/2022 6:03 AM, Richard Damon wrote:
> > Yes, but the behavior we are looking at is NOT the results of the
> > PARTIAL simulation that H does, but either the COMPLETE simulation
> > of P or the direct execution of P.
>
>
ANd where did I say that was done by H?

On 9/20/2022 7:38 PM, Richard Damon wrote:
> On 9/20/22 7:17 PM, olcott wrote:
>> On 9/20/2022 5:39 PM, Richard Damon wrote:
>>>
>>> On 9/20/22 9:55 AM, olcott wrote:
>>>> On 9/20/2022 6:03 AM, Richard Damon wrote:
>>>>> On 9/19/22 11:56 PM, olcott wrote:
>>>>>> On 9/19/2022 10:46 PM, Richard Damon wrote:
>>>>>>> On 9/19/22 11:39 PM, olcott wrote:
>>>>>>>> On 9/19/2022 10:32 PM, Richard Damon wrote:
>>>>>>>>> On 9/19/22 11:19 PM, olcott wrote:
>>>>>>>>>> On 9/19/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/19/22 10:12 PM, olcott wrote:
>>>>>>>>>>>> On 9/19/2022 8:24 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/19/22 8:59 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/19/2022 7:52 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/19/22 8:15 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/19/2022 6:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/19/22 6:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/19/2022 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/19/22 11:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/19/2022 5:55 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/18/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 9:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports its direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it doesn't. It is only correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *IF* its input wouldn't halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  > If Hx DOES directly execute its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input, then it will NEVER report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  > non-halting, and yes, then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input Px built from THAT Hx will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And since Hx doesn't directly execute
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Its basis for correctly deciding that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of this input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt is a wild guess.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, it guesses wrong about the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question that is being asked of it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why do I have to tell you the same thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 500 times and you still don't get it?  My
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theory is that you are a liar only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> interested in rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No halt decider ever directly executes its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input yet must correctly predict the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of this directly executed or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, THE behavior of direct execution or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation, not by the decider, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just done.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you want to add the words "by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider", you need a source for that, which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have failed to do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> First you must agree that every Hx returning
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 does correctly report the halt status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of what its direct execution of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px(Px) would be if it directly executed this
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No. because no Hx that does a direct
>>>>>>>>>>>>>>>>>>>>>>>>>>> execution even gives an answer, so your
>>>>>>>>>>>>>>>>>>>>>>>>>>> statement is ILLOGICAL.
>>>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders are not supposed to do a direct
>>>>>>>>>>>>>>>>>>>>>>>>>> execution and you know this so what the Hell
>>>>>>>>>>>>>>>>>>>>>>>>>> are you trying to pull here?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Right, the aren't supposed to so why do you
>>>>>>>>>>>>>>>>>>>>>>>>> think they need to act like they did?
>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must correctly predict what the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of their directly executed or correctly
>>>>>>>>>>>>>>>>>>>>>>>> simulated input would be Hx(Px,Px)==0 does that.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Why do you say that?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You have already agreed that if main calls P(P),
>>>>>>>>>>>>>>>>>>>>>>> and H(P,P) returns 0 that P(P) will return in
>>>>>>>>>>>>>>>>>>>>>>> finite time, so the "directly executed input" of
>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is shown to be Halting in this case.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The only correct invocation of P(P) that must
>>>>>>>>>>>>>>>>>>>>>> considered is the invocation by H. As I have been
>>>>>>>>>>>>>>>>>>>>>> always saying the other one is irrelevant.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int H(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This instance of P never halts.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, wrong terminology.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That VERSION of P never halts, and that version of
>>>>>>>>>>>>>>>>>>>>> H never gives an answer, so is wrong.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *A halt decider always only predicts the behavior of
>>>>>>>>>>>>>>>>>>>> its input*, the above behavior is what Hx must
>>>>>>>>>>>>>>>>>>>> predict. By using an adapted version of the infinite
>>>>>>>>>>>>>>>>>>>> recursion behavior pattern a simulating halt decider
>>>>>>>>>>>>>>>>>>>> does correctly predict the above behavior in a
>>>>>>>>>>>>>>>>>>>> finite number of steps and as a pure function of its
>>>>>>>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, just shows you don't know what you are talking
>>>>>>>>>>>>>>>>>>> about.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> All of your reasoning has been of the form that the
>>>>>>>>>>>>>>>>>> halt decider must execute its non-halting input and
>>>>>>>>>>>>>>>>>> then report on its behavior after its infinite
>>>>>>>>>>>>>>>>>> execution (never) completes.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, it doesn't have to execute its non-halting input,
>>>>>>>>>>>>>>>>> it need to recognize IF its input is non-halting
>>>>>>>>>>>>>>>>> without actually executing it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then all of the times that you said the problem with my
>>>>>>>>>>>>>>>> halt decider is that it didn't execute its input you
>>>>>>>>>>>>>>>> knew that you were lying.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When did I say H needed to execute its input?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I've said that its answer needs to be based on the
>>>>>>>>>>>>>>> behavior of just executing the input, return 1 if an
>>>>>>>>>>>>>>> execution of the input would halt, and 0 if t wouldn't.
>>>>>>>>>>>>>> Thus the Hx halt status decision must be based on the
>>>>>>>>>>>>>> behavior of just executing the H(P,P) input:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Next you will say that although:
>>>>>>>>>>>>>> "its answer needs to be based on the behavior of just
>>>>>>>>>>>>>> executing the input"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You don't really mean:
>>>>>>>>>>>>>> "its answer needs to be based on the behavior of just
>>>>>>>>>>>>>> executing the input"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, you can't show where I said what you claim I said, so
>>>>>>>>>>>>> you are just admitting you are lying.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You don't seem to understand that we can have independent
>>>>>>>>>>>>> execution of things
>>>>>>>>>>>>
>>>>>>>>>>>> When we have independent execution of a dependent
>>>>>>>>>>>> computation we get an incorrect measure of the actual
>>>>>>>>>>>> behavior, likewise with the reverse.
>>>>>>>>>>>
>>>>>>>>>>> What is the "dependent computation" that is giving you a
>>>>>>>>>>> problem?
>>>>>>>>>>>
>>>>>>>>>> The halting value of P depends on the return value from H or
>>>>>>>>>> not depending on where P is executed. This changes the
>>>>>>>>>> behavior of P
>>>>>>>>>> depending on where P is executed.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, the Halting Value of P depends on the return value from H,
>>>>>>>>> ALWAYS.
>>>>>>>>>
>>>>>>>> By the same reasoning a computer program that is never executed
>>>>>>>> must still produce results.
>>>>>>>>
>>>>>>>
>>>>>>> No, but a computer program that is never executed will still have
>>>>>>> a defined a result if it was run.
>>>>>>
>>>>>> H aborts its simulation of P before P invokes H. The halt criteria
>>>>>> is best understood as the infinite recursion behavior pattern.
>>>>>> Once this is understood then the infinite simulation adaptation
>>>>>> can be understood.
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, but the behavior we are looking at is NOT the results of the
>>>>> PARTIAL simulation that H does, but either the COMPLETE simulation
>>>>> of P or the direct execution of P.
>>>>
>>>> So you are back to saying that the only correct halt decider is a
>>>> halt decider that never returns because it is stuck in infinite
>>>> recursion or infinite simulation.
>>>>
>>>>
>>>
>>> Where did I say that?
>>
>> On 9/20/2022 6:03 AM, Richard Damon wrote:
>>  > Yes, but the behavior we are looking at is NOT the results of the
>>  > PARTIAL simulation that H does, but either the COMPLETE simulation
>>  > of P or the direct execution of P.
>>
>>
> ANd where did I say that was done by H?
>
Then you are agreeing that a halt decider does not need to do a complete
simulation or a complete execution of its input to correctly determine
that this input does not halt?

On 9/20/22 8:50 PM, olcott wrote:
> On 9/20/2022 7:38 PM, Richard Damon wrote:
>> On 9/20/22 7:17 PM, olcott wrote:
>>> On 9/20/2022 5:39 PM, Richard Damon wrote:
>>>>
>>>> On 9/20/22 9:55 AM, olcott wrote:
>>>>> On 9/20/2022 6:03 AM, Richard Damon wrote:
>>>>>> On 9/19/22 11:56 PM, olcott wrote:
>>>>>>> On 9/19/2022 10:46 PM, Richard Damon wrote:
>>>>>>>> On 9/19/22 11:39 PM, olcott wrote:
>>>>>>>>> On 9/19/2022 10:32 PM, Richard Damon wrote:
>>>>>>>>>> On 9/19/22 11:19 PM, olcott wrote:
>>>>>>>>>>> On 9/19/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/19/22 10:12 PM, olcott wrote:
>>>>>>>>>>>>> On 9/19/2022 8:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/19/22 8:59 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/19/2022 7:52 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/19/22 8:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/19/2022 6:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/19/22 6:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/19/2022 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/19/22 11:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/19/2022 5:55 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 9:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This instance of Hx(Px,Px)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reports its direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it doesn't. It is only correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *IF* its input wouldn't halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  > If Hx DOES directly execute its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input, then it will NEVER report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  > non-halting, and yes, then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input Px built from THAT Hx will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And since Hx doesn't directly execute
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Its basis for correctly deciding that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never halt is a wild guess.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, it guesses wrong about the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question that is being asked of it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why do I have to tell you the same thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 500 times and you still don't get it?  My
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theory is that you are a liar only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> interested in rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No halt decider ever directly executes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input yet must correctly predict the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of this directly executed or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, THE behavior of direct execution or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation, not by the decider,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but just done.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you want to add the words "by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider", you need a source for that,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which you have failed to do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> First you must agree that every Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returning 0 does correctly report the halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of the behavior of what its direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of Px(Px) would be if it directly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> executed this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> No. because no Hx that does a direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution even gives an answer, so your
>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement is ILLOGICAL.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders are not supposed to do a direct
>>>>>>>>>>>>>>>>>>>>>>>>>>> execution and you know this so what the Hell
>>>>>>>>>>>>>>>>>>>>>>>>>>> are you trying to pull here?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Right, the aren't supposed to so why do you
>>>>>>>>>>>>>>>>>>>>>>>>>> think they need to act like they did?
>>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must correctly predict what the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior of their directly executed or
>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input would be Hx(Px,Px)==0
>>>>>>>>>>>>>>>>>>>>>>>>> does that.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Why do you say that?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You have already agreed that if main calls P(P),
>>>>>>>>>>>>>>>>>>>>>>>> and H(P,P) returns 0 that P(P) will return in
>>>>>>>>>>>>>>>>>>>>>>>> finite time, so the "directly executed input" of
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is shown to be Halting in this case.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The only correct invocation of P(P) that must
>>>>>>>>>>>>>>>>>>>>>>> considered is the invocation by H. As I have been
>>>>>>>>>>>>>>>>>>>>>>> always saying the other one is irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int H(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This instance of P never halts.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, wrong terminology.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That VERSION of P never halts, and that version of
>>>>>>>>>>>>>>>>>>>>>> H never gives an answer, so is wrong.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *A halt decider always only predicts the behavior
>>>>>>>>>>>>>>>>>>>>> of its input*, the above behavior is what Hx must
>>>>>>>>>>>>>>>>>>>>> predict. By using an adapted version of the
>>>>>>>>>>>>>>>>>>>>> infinite recursion behavior pattern a simulating
>>>>>>>>>>>>>>>>>>>>> halt decider does correctly predict the above
>>>>>>>>>>>>>>>>>>>>> behavior in a finite number of steps and as a pure
>>>>>>>>>>>>>>>>>>>>> function of its inputs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, just shows you don't know what you are talking
>>>>>>>>>>>>>>>>>>>> about.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> All of your reasoning has been of the form that the
>>>>>>>>>>>>>>>>>>> halt decider must execute its non-halting input and
>>>>>>>>>>>>>>>>>>> then report on its behavior after its infinite
>>>>>>>>>>>>>>>>>>> execution (never) completes.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, it doesn't have to execute its non-halting
>>>>>>>>>>>>>>>>>> input, it need to recognize IF its input is
>>>>>>>>>>>>>>>>>> non-halting without actually executing it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then all of the times that you said the problem with my
>>>>>>>>>>>>>>>>> halt decider is that it didn't execute its input you
>>>>>>>>>>>>>>>>> knew that you were lying.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When did I say H needed to execute its input?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I've said that its answer needs to be based on the
>>>>>>>>>>>>>>>> behavior of just executing the input, return 1 if an
>>>>>>>>>>>>>>>> execution of the input would halt, and 0 if t wouldn't.
>>>>>>>>>>>>>>> Thus the Hx halt status decision must be based on the
>>>>>>>>>>>>>>> behavior of just executing the H(P,P) input:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Next you will say that although:
>>>>>>>>>>>>>>> "its answer needs to be based on the behavior of just
>>>>>>>>>>>>>>> executing the input"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You don't really mean:
>>>>>>>>>>>>>>> "its answer needs to be based on the behavior of just
>>>>>>>>>>>>>>> executing the input"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, you can't show where I said what you claim I said, so
>>>>>>>>>>>>>> you are just admitting you are lying.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You don't seem to understand that we can have independent
>>>>>>>>>>>>>> execution of things
>>>>>>>>>>>>>
>>>>>>>>>>>>> When we have independent execution of a dependent
>>>>>>>>>>>>> computation we get an incorrect measure of the actual
>>>>>>>>>>>>> behavior, likewise with the reverse.
>>>>>>>>>>>>
>>>>>>>>>>>> What is the "dependent computation" that is giving you a
>>>>>>>>>>>> problem?
>>>>>>>>>>>>
>>>>>>>>>>> The halting value of P depends on the return value from H or
>>>>>>>>>>> not depending on where P is executed. This changes the
>>>>>>>>>>> behavior of P
>>>>>>>>>>> depending on where P is executed.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, the Halting Value of P depends on the return value from H,
>>>>>>>>>> ALWAYS.
>>>>>>>>>>
>>>>>>>>> By the same reasoning a computer program that is never executed
>>>>>>>>> must still produce results.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, but a computer program that is never executed will still
>>>>>>>> have a defined a result if it was run.
>>>>>>>
>>>>>>> H aborts its simulation of P before P invokes H. The halt
>>>>>>> criteria is best understood as the infinite recursion behavior
>>>>>>> pattern. Once this is understood then the infinite simulation
>>>>>>> adaptation can be understood.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, but the behavior we are looking at is NOT the results of the
>>>>>> PARTIAL simulation that H does, but either the COMPLETE simulation
>>>>>> of P or the direct execution of P.
>>>>>
>>>>> So you are back to saying that the only correct halt decider is a
>>>>> halt decider that never returns because it is stuck in infinite
>>>>> recursion or infinite simulation.
>>>>>
>>>>>
>>>>
>>>> Where did I say that?
>>>
>>> On 9/20/2022 6:03 AM, Richard Damon wrote:
>>>  > Yes, but the behavior we are looking at is NOT the results of the
>>>  > PARTIAL simulation that H does, but either the COMPLETE simulation
>>>  > of P or the direct execution of P.
>>>
>>>
>> ANd where did I say that was done by H?
>>
> Then you are agreeing that a halt decider does not need to do a complete
> simulation or a complete execution of its input to correctly determine
> that this input does not halt?
>