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?

>
> bool Answer_No_with_params(ptr x, ptr y)
> {
>   return false;
> }
> provides the correct answer.

Boy are you dumb.

>
> Thus every Hx(ptr x, ptr y) that returns 0 also provides the correct
> answer.
>
>
>

Nope, you are just proving you are totally stupid if you think this
program doesn't halt:

bool Hx(ptr x, ptr y) {
return 0;
}

void Px(ptr x) {
if(Hx(x,x)) {
while(1) ;
}
}

int main() {
Px(Px);
}

or if you insist on simulating:

int main() {
Simulate(Px, Px);
}

It is CLEAR that this program Halts, therefore the answer of FALSE that
Hx(Px,Px) gives is wrong.

What is your explaination of this?

Dodging this will just prove your stupidity and that you are a
pathological liar.