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?

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