On 9/7/2022 8:50 PM, Richard Damon wrote:
> On 9/7/22 9:43 PM, olcott wrote:
>> On 9/7/2022 8:21 PM, Richard Damon wrote:
>>>
>>> On 9/7/22 9:12 PM, olcott wrote:
>>>> On 9/7/2022 8:02 PM, Richard Damon wrote:
>>>>> On 9/7/22 8:59 PM, olcott wrote:
>>>>>> On 9/7/2022 7:36 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/7/22 7:01 PM, olcott wrote:
>>>>>>>> On 9/7/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>> On 9/7/22 10:14 AM, olcott wrote:
>>>>>>>>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>>>>>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/6/22 1:56 PM, olcott wrote:
>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THIS HAS BEEN AGREED TO* // *understanding the above
>>>>>>>>>>>>>>>> code proves this*
>>>>>>>>>>>>>>>> There are zero elements of infinite set of Hx/Px pairs
>>>>>>>>>>>>>>>> such that the correct *partial or complete* simulation
>>>>>>>>>>>>>>>> of Px by Hx reaches the final state of Px.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS (as a subset) FROM ABOVE*
>>>>>>>>>>>>>>>> (A) Every element of the infinite set of Hx/Px pairs
>>>>>>>>>>>>>>>> that does a correct and complete simulation of its input
>>>>>>>>>>>>>>>> never reaches the final state of this input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
>>>>>>>>>>>>>>>> (B) A correct and complete simulation of this input
>>>>>>>>>>>>>>>> derives the actual behavior of this input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>>>>>>>>> (C) The actual behavior of this input never reaches the
>>>>>>>>>>>>>>>> final state of this input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But Every H that IS a UTM fails to answer, and every H
>>>>>>>>>>>>>>> that answers fails to be a UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no
>>>>>>>>>>>>>>> Px that have their Hx return 0 and also have a UTM
>>>>>>>>>>>>>>> showing them to be non-halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus, the only Px's you have show to be non-halting are
>>>>>>>>>>>>>>> those associsted with Hx's that don't answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When the criteria for a simulating halt decider (SHD) is
>>>>>>>>>>>>>>>> to correctly predict that its complete and correct
>>>>>>>>>>>>>>>> simulation of its input would never reach the final
>>>>>>>>>>>>>>>> state of this simulated input then:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *You seem to insufficiently appreciate what this infinite
>>>>>>>>>>>>>> set comprises*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> One of the elements of this set correctly simulates some
>>>>>>>>>>>>>> fixed number of steps of its input and then after that
>>>>>>>>>>>>>> exactly performs every chess move that deep blue performed
>>>>>>>>>>>>>> when it defeated Kasparov.
>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Another element of this set correctly simulates some fixed
>>>>>>>>>>>>>> number of steps of its input and then after that
>>>>>>>>>>>>>> translates the Lords prayer into ancient Egyptian.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If that it the case then at least one element of this set
>>>>>>>>>>>>>> returns 0 on the basis that it correctly matched a correct
>>>>>>>>>>>>>> infinite behavior pattern.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>>>>>>>>
>>>>>>>>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And NO element of the set of Hx correctly decides on its own
>>>>>>>>>>> Px that calls that particular Hx.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every element of the Hx/Px pairs that simply returns 0
>>>>>>>>>> correctly predicts that its correct and complete simulation of
>>>>>>>>>> its input would never reach the final state of this input
>>>>>>>>>> because every element of the infinite set of Hx/Px pairs that
>>>>>>>>>> correctly and completely simulates its input never reaches the
>>>>>>>>>> final state of this input.
>>>>>>>>>
>>>>>>>>> No, it doesn't because UTM(Px,Px) for those Hx that return 0
>>>>>>>>> from Hx(Px,P) will Halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If all X are Y and you disagree then you are wrong.
>>>>>>>
>>>>>>> What are X's and what are Y's?
>>>>>>>
>>>>>>>>
>>>>>>>> If every correct and complete simulation of the input to Hx
>>>>>>>> never stops running and it is the job of some Hx to predict
>>>>>>>> whether or not the correct and complete simulation of the input
>>>>>>>> to Hx would ever stop running then even this Hx is correct:
>>>>>>>
>>>>>>> Right, EVERT Hx that does a correct and complete simulation of
>>>>>>> its input NEVER gives an answer about its corresponding input.
>>>>>>> Yes, those inputs are non-halting, but Hx fails to identify them,
>>>>>>> and thus Hx isn't even a decider.
>>>>>>>
>>>>>>> The OTHER Hx's, that do abort their simulations, do NOT do a
>>>>>>> complete simulation of their input, and for EVERY one of them,
>>>>>>> UTM(Px,Px) for the Px built on them will Halt, so they are wrong.
>>>>>>>
>>>>>>> Yes, all X are Y, as in ALL your Hx's are WRONG, because they
>>>>>>> fail to meet the requirements of a Halt Decider.
>>>>>>>
>>>>>>>>
>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>> {
>>>>>>>>    return 0;
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Right, and the Px built on that Halts, so it is wrong.
>>>>>>>
>>>>>> This function computes the correct answer to every question where
>>>>>> the answer is yes.
>>>>>>
>>>>>> bool Answer()
>>>>>> {
>>>>>>    return true;
>>>>>> }
>>>>>>
>>>>>
>>>>> So, since the CORRECT answer to the Hx(Px,Px) for the Px of the
>>>>> above Hx is Halt, it isn't right.
>>>>>
>>>>
>>>>
>>>> This function computes the correct answer to every question where
>>>> the answer is no.
>>>>
>>>> bool Answer_No()
>>>> {
>>>>    return false;
>>>> }
>>>
>>> So.
>>>>
>>>> When the question is:
>>>> Does the complete and correct simulation of Px by Hx ever stop running?
>>>
>>> And the answer for the Px built on that Hx is YES.
>>>
>>> Px(Px) calls your Hx(Px,Px) it immediately returns false and Px halts.
>>>
>>> What is wrong with that simulation?
>>>
>>> Even YOU should be able to see that.
>>>
>>>>
>>>> Answer_No() provides the correct answer.
>>>
>>> How, since it halts?
>> void Px(ptr x)
>> {
>>    int Halt_Status = Hx(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> *You forgot that you agreed that you agreed that the answer is NO*
>> Does the complete and correct simulation of Px by Hx ever stop running?
>>
>>
>
> I never agreed that the answer was No. You are just lying again.
>
> I agreed that for the Hx that NEVER stops simulating, the answer is no,
>

You didn't understand the a complete simulation of an input that never
stops running also never stops simulating?

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