On 6/26/2021 10:06 AM, Richard Damon wrote:
> On 6/26/21 10:55 AM, olcott wrote:
>> On 6/26/2021 5:32 AM, Richard Damon wrote:
>>> On 6/25/21 11:07 PM, olcott wrote:
>>>> On 6/25/2021 9:07 PM, Richard Damon wrote:
>>>>> On 6/25/21 9:46 PM, olcott wrote:
>>>>>> On 6/25/2021 8:37 PM, Richard Damon wrote:
>>>>>>> On 6/25/21 9:01 PM, olcott wrote:
>>>>>>>> On 6/25/2021 7:40 PM, Richard Damon wrote:
>>>>>>>>> On 6/25/21 6:56 PM, olcott wrote:
>>>>>>>>>> On 6/25/2021 4:59 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/25/21 4:40 PM, olcott wrote:
>>>>>>>>>>>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/25/21 2:50 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> WRONG. P is DEFINED based on H. If you Hypothetically create
>>>>>>>>>>>>>>> a P
>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>> doesn't follow that form, then you are hypothetically
>>>>>>>>>>>>>>> creating
>>>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>>>> and can't use it to for anything logical.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Of every possible encoding of simulating partial halt
>>>>>>>>>>>>>> decider H
>>>>>>>>>>>>>> that can
>>>>>>>>>>>>>> possibly exist  H*, if H* never aborts the simulation of its
>>>>>>>>>>>>>> input
>>>>>>>>>>>>>> results in the infinite execution of the invocation of of P(P)
>>>>>>>>>>>>>> then a
>>>>>>>>>>>>>> simulating halt decider H that does abort its simulation of
>>>>>>>>>>>>>> this
>>>>>>>>>>>>>> input
>>>>>>>>>>>>>> does correctly decide that this input does specify the never
>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>> behavior of an infinite chain of invocations.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, if H* is an element of the set of non-aborting deciders
>>>>>>>>>>>>> (Hn), P
>>>>>>>>>>>>> will result in infinite recursion,
>>>>>>>>>>>>
>>>>>>>>>>>> Which logically entails beyond all possible doubt that the
>>>>>>>>>>>> set of
>>>>>>>>>>>> encodings of simulating partial halt deciders H2* that do abort
>>>>>>>>>>>> the
>>>>>>>>>>>> simulation of the (P,P) input would correctly report that this
>>>>>>>>>>>> input
>>>>>>>>>>>> never halts.
>>>>>>>>>>>
>>>>>>>>>>> WHY?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Axiom(1) Every computation that never halts unless its
>>>>>>>>>> simulation is
>>>>>>>>>> aborted is a computation that never halts. This verified as
>>>>>>>>>> true on
>>>>>>>>>> the
>>>>>>>>>> basis of the meaning of its words.
>>>>>>>>>
>>>>>>>>> WRONG.
>>>>>>>>>
>>>>>>>>> Your test does not match the plain meaning of the words, as has
>>>>>>>>> been
>>>>>>>>> explained many times.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Those words may be over your head, yet several others understand
>>>>>>>> that
>>>>>>>> they are necessarily correct.
>>>>>>>
>>>>>>> I have seen NO ONE agree to your interpretation of it. The plain
>>>>>>> meaning
>>>>>>> is that if it can be shown that if the given instance of the
>>>>>>> simulator
>>>>>>> simulating a given input doesn't stop its simulation that this
>>>>>>> simulation will run forevr, then the machine that is being simulated
>>>>>>> can
>>>>>>> be corrected decided as non-Halting.
>>>>>>>
>>>>>>> An more formal way to say that is if UTM(P,I) is non-halting then
>>>>>>> it is
>>>>>>> correct for H(P,I) to return the non-halting result.
>>>>>>>
>>>>>>> This actually follows since UTM(P,I) will be non-halting if and
>>>>>>> only if
>>>>>>> P(I) is non-halting by the definition of a UTM, so that statement is
>>>>>>> trivially proven.
>>>>>>>
>>>>>>> Your interpretation, where even if a copy of the algorithm of H is
>>>>>>> included in P and that included copy needs to abort the simulation of
>>>>>>> the copy of the machine that it was given, can be PROVEN wrong, as
>>>>>>> even
>>>>>>> you have shown that P(P) in this case does Halt, thus your claimed
>>>>>>> correct answer is wrong by the definition of the problem.
>>>>>>>
>>>>>>> Only if you define that your answer isn't actually supposed to be the
>>>>>>> answer to the halting problem can you justify your answer to be
>>>>>>> correct,
>>>>>>> but then you proof doesn't achieve the goal you claim.
>>>>>>>
>>>>>>>>
>>>>>>>>> Note, it is easy to show that your interpretation is wrong since
>>>>>>>>> even
>>>>>>>>> you admit that Linz H^, now called P by you will come to its end
>>>>>>>>> and
>>>>>>>>> halt when given it own representation as its input, and thus is BY
>>>>>>>>> DEFINITION a Halting Computation, Thus the H deciding it didn't
>>>>>>>>> need to
>>>>>>>>> abort its execution to get the wrong answer of Non-Halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Because at least one invocation of the infinite invocation chain
>>>>>>>> specified by P(P) had to be terminated to prevent the infinite
>>>>>>>> execution
>>>>>>>> of this infinite invocation chain it is confirmed beyond all
>>>>>>>> possible
>>>>>>>> doubt that P(P) specifies an invocation chain.
>>>>>>>
>>>>>>> WRONG. Given that we have an H that can answer H(P,P) because it
>>>>>>> knows
>>>>>>> at least enough to terminate the pattern you describe, then when
>>>>>>> we run
>>>>>>> P(P) then because the H within it also knows to abort this sequence
>>>>>>> (since it is built on the same algorithm) this P is NOT part of an
>>>>>>> infinite chain of execution, and thus its H can return its (wrong)
>>>>>>> answer to it and that P can then Halt.
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> Now I have told this this several hundred times.
>>>>>>
>>>>>>
>>>>>
>>>>> WRONG.
>>>>>
>>>>> P(P) starts.
>>>>>
>>>>> Calls H(P,P)
>>>>>
>>>>> H starts the simulation.
>>>>>
>>>>> H simulates P starting
>>>>>
>>>>> H simulates P calling H
>>>>>
>>>>> H simulates H starting its simulation
>>>>>
>>>>> H simulates H simulating P starting
>>>>>
>>>>> H simulates H simulating P calling H
>>>>>
>>>>> The first H about here detects what it THINKS is an infinite execution
>>>>>
>>>>> THe first H aborts its simulation
>>>>>
>>>>> The first H returns its answer (Non-Halting) to its caller
>>>>>
>>>>> P then Halts
>>>>>
>>>>> Showing P is a Halting Computation.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>
>>> Yes, P halts because the H it contains terminated the simulation of
>>> another copy of its description.
>>>
>>> YOUR problem is that you think that actually means something, it doesn't
>>>
>>
>> Whenever one invocation of the infinite invocation chain of infinite
>> recursion is aborted the whole chain terminates.
>
> WRONG, if the aborting is occurring inside the chain, which it is in
> this case.
>

In the computation int main() { P(P); } If no P ever halts unless some H
aborts some P this proves beyond all possible doubt that P(P) specifies
an infinitely recursive chain of invocations.

That it took me so long to find these words proves that I am a
relatively terrible communicator. On the other hand these words do
unequivocally validate that my logic was correct all along.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein