On 9/7/2022 9:07 PM, Richard Damon wrote:
> On 9/7/22 9:58 PM, olcott wrote:
>> 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?
>>
>>
> Yes, I understand that.

On 9/7/22 10:17 PM, olcott wrote:
> On 9/7/2022 9:07 PM, Richard Damon wrote:
>> On 9/7/22 9:58 PM, olcott wrote:
>>> 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?
>>>
>>>
>> Yes, I understand that.
>
> Then why did you say this?
> >>> I never agreed that the answer was No. You are just lying again.
>
>

On 9/7/2022 9:23 PM, Richard Damon wrote:
> On 9/7/22 10:17 PM, olcott wrote:
>> On 9/7/2022 9:07 PM, Richard Damon wrote:
>>> On 9/7/22 9:58 PM, olcott wrote:
>>>> 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?
>>>>
>>>>
>>> Yes, I understand that.
>>
>> Then why did you say this?
>>  >>> I never agreed that the answer was No. You are just lying again.
>>
>>
>
> The answer for THAT Px is Halting.
>

On 9/7/22 10:35 PM, olcott wrote:
> On 9/7/2022 9:23 PM, Richard Damon wrote:
>> On 9/7/22 10:17 PM, olcott wrote:
>>> On 9/7/2022 9:07 PM, Richard Damon wrote:
>>>> On 9/7/22 9:58 PM, olcott wrote:
>>>>> 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?
>>>>>
>>>>>
>>>> Yes, I understand that.
>>>
>>> Then why did you say this?
>>>  >>> I never agreed that the answer was No. You are just lying again.
>>>
>>>
>>
>> The answer for THAT Px is Halting.
>>
>
> I refer to the set of every Hx/Px pair where Hx performs a complete
> simulation of its input which means that the simulation never stops
> running *AND YOU SAY THEY STOP RUNNING* ?
>
=

On 9/7/2022 9:48 PM, Richard Damon wrote:
>
> On 9/7/22 10:35 PM, olcott wrote:
>> On 9/7/2022 9:23 PM, Richard Damon wrote:
>>> On 9/7/22 10:17 PM, olcott wrote:
>>>> On 9/7/2022 9:07 PM, Richard Damon wrote:
>>>>> On 9/7/22 9:58 PM, olcott wrote:
>>>>>> 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?
>>>>>>
>>>>>>
>>>>> Yes, I understand that.
>>>>
>>>> Then why did you say this?
>>>>  >>> I never agreed that the answer was No. You are just lying again.
>>>>
>>>>
>>>
>>> The answer for THAT Px is Halting.
>>>
>>
>> I refer to the set of every Hx/Px pair where Hx performs a complete
>> simulation of its input which means that the simulation never stops
>> running *AND YOU SAY THEY STOP RUNNING* ?
>>
> =
>
> But this isn't a problem of "Sets"
>

On 9/7/22 11:09 PM, olcott wrote:
> On 9/7/2022 9:48 PM, Richard Damon wrote:
>>
>> On 9/7/22 10:35 PM, olcott wrote:
>>> On 9/7/2022 9:23 PM, Richard Damon wrote:
>>>> On 9/7/22 10:17 PM, olcott wrote:
>>>>> On 9/7/2022 9:07 PM, Richard Damon wrote:
>>>>>> On 9/7/22 9:58 PM, olcott wrote:
>>>>>>> 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?
>>>>>>>
>>>>>>>
>>>>>> Yes, I understand that.
>>>>>
>>>>> Then why did you say this?
>>>>>  >>> I never agreed that the answer was No. You are just lying again.
>>>>>
>>>>>
>>>>
>>>> The answer for THAT Px is Halting.
>>>>
>>>
>>> I refer to the set of every Hx/Px pair where Hx performs a complete
>>> simulation of its input which means that the simulation never stops
>>> running *AND YOU SAY THEY STOP RUNNING* ?
>>>
>> =
>>
>> But this isn't a problem of "Sets"
>>
>
> Does any complete and correct simulation of Px by Hx ever stop running?
>
>

On 9/7/2022 10:23 PM, Richard Damon wrote:
> On 9/7/22 11:09 PM, olcott wrote:
>> On 9/7/2022 9:48 PM, Richard Damon wrote:
>>>
>>> On 9/7/22 10:35 PM, olcott wrote:
>>>> On 9/7/2022 9:23 PM, Richard Damon wrote:
>>>>> On 9/7/22 10:17 PM, olcott wrote:
>>>>>> On 9/7/2022 9:07 PM, Richard Damon wrote:
>>>>>>> On 9/7/22 9:58 PM, olcott wrote:
>>>>>>>> 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?
>>>>>>>>
>>>>>>>>
>>>>>>> Yes, I understand that.
>>>>>>
>>>>>> Then why did you say this?
>>>>>>  >>> I never agreed that the answer was No. You are just lying again.
>>>>>>
>>>>>>
>>>>>
>>>>> The answer for THAT Px is Halting.
>>>>>
>>>>
>>>> I refer to the set of every Hx/Px pair where Hx performs a complete
>>>> simulation of its input which means that the simulation never stops
>>>> running *AND YOU SAY THEY STOP RUNNING* ?
>>>>
>>> =
>>>
>>> But this isn't a problem of "Sets"
>>>
>>
>> Does any complete and correct simulation of Px by Hx ever stop running?
>>
>>
>
> No, but most Hx never do a complete simulatioh, so it doesn't matter.

On 9/7/22 11:32 PM, olcott wrote:
> On 9/7/2022 10:23 PM, Richard Damon wrote:
>> On 9/7/22 11:09 PM, olcott wrote:
>>> On 9/7/2022 9:48 PM, Richard Damon wrote:
>>>>
>>>> On 9/7/22 10:35 PM, olcott wrote:
>>>>> On 9/7/2022 9:23 PM, Richard Damon wrote:
>>>>>> On 9/7/22 10:17 PM, olcott wrote:
>>>>>>> On 9/7/2022 9:07 PM, Richard Damon wrote:
>>>>>>>> On 9/7/22 9:58 PM, olcott wrote:
>>>>>>>>> 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?
>>>>>>>>>
>>>>>>>>>
>>>>>>>> Yes, I understand that.
>>>>>>>
>>>>>>> Then why did you say this?
>>>>>>>  >>> I never agreed that the answer was No. You are just lying
>>>>>>> again.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> The answer for THAT Px is Halting.
>>>>>>
>>>>>
>>>>> I refer to the set of every Hx/Px pair where Hx performs a complete
>>>>> simulation of its input which means that the simulation never stops
>>>>> running *AND YOU SAY THEY STOP RUNNING* ?
>>>>>
>>>> =
>>>>
>>>> But this isn't a problem of "Sets"
>>>>
>>>
>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>>
>>>
>>
>> No, but most Hx never do a complete simulatioh, so it doesn't matter.
>
> There are an infinite number that do a complete simulation and an
> infinite number that do not.

On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
> >>>>>>>>>>>>>>>>>>>>>> }

> Does any complete and correct simulation of Px by Hx ever stop running?

We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.

You still seem to think that if you are clever enough, and careful enough, then you can write an Hx which will do a complete and correct simulation of Px, but it is not possible.

On 9/8/2022 8:07 AM, Paul N wrote:
> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>> }
>
>> Does any complete and correct simulation of Px by Hx ever stop running?
>
> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
>

I have told you this at least fifteen times now and you somehow make
sure to keep forgetting (as if you don't give a rat's ass for the truth
and only want to disagree even at the expense of the truth):

void Infinite_Loop()
{ HERE: goto HERE;
}

void Infinite_Recursion(int N)
{ Infinite_Recursion(N);
}

Simulating halt deciders (SHD) never do a complete and correct
simulation of any non-halting input. Instead they match non-halting
behavior patterns that predict what the behavior of their input would be
if they did a complete and correct simulation of this input.

In the case of the infinite set of Hx/Px pairs where some of these pairs
do a complete and correct simulation of their input, none of these ever
halt, thus this Hx/Px pair correctly predicts the behavior of the
correct and complete simulation of its input: (Px, Px)

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

We adapt this correct guessing halt decider into a SHD as I have already
shown.

*Here is the updated version*
https://liarparadox.org/2022_09_07.zip

> You still seem to think that if you are clever enough, and careful enough, then you can write an Hx which will do a complete and correct simulation of Px, but it is not possible.

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

On Thursday, September 8, 2022 at 3:01:42 PM UTC+1, olcott wrote:
> On 9/8/2022 8:07 AM, Paul N wrote:
> > On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >
> >> Does any complete and correct simulation of Px by Hx ever stop running?
> >
> > We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
> >
> I have told you this at least fifteen times now and you somehow make
> sure to keep forgetting (as if you don't give a rat's ass for the truth
> and only want to disagree even at the expense of the truth):
>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> void Infinite_Recursion(int N)
> {
> Infinite_Recursion(N);
> }
>
> Simulating halt deciders (SHD) never do a complete and correct
> simulation of any non-halting input. Instead they match non-halting
> behavior patterns that predict what the behavior of their input would be
> if they did a complete and correct simulation of this input.
>
> In the case of the infinite set of Hx/Px pairs where some of these pairs
> do a complete and correct simulation of their input, none of these ever
> halt, thus this Hx/Px pair correctly predicts the behavior of the
> correct and complete simulation of its input: (Px, Px)
> int Hx(ptr x, ptr y)
> {
> return 0;
> }
> We adapt this correct guessing halt decider into a SHD as I have already
> shown.

You specifically asked "Does any complete and correct simulation of Px by Hx ever stop running?" and so that was the question I answered. You didn't ask about an SHD.

You've also posted the code to two function which you say your SHD assesses correctly. I'm saying that it doesn't decide Px correctly, which (a) is the function you mentioned in your question, and (b) is the function which shows your SHD does not, and cannot, work properly.

You can't prove that your SHD works simply by showing that different things work differently.

> *Here is the updated version*
> https://liarparadox.org/2022_09_07.zip
> > You still seem to think that if you are clever enough, and careful enough, then you can write an Hx which will do a complete and correct simulation of Px, but it is not possible.

On 9/8/2022 8:07 AM, Paul N wrote:
> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>> }
>
>> Does any complete and correct simulation of Px by Hx ever stop running?
>
> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
>

*We will call this the UTM subset*
We are discussing the infinite set of Hx/Px pairs. An infinite subset of
these do a complete and correct simulation of their input.

Perhaps you fail to comprehend that all of this subset would remain
stuck in infinitely recursive simulation such that Px never reaches its
final state and the simulation never stops, thus Hx never returns any
value.

*Of the remaining subsets*
(1) One of these ignores its input and translates the Lord's prayer into
ancient Egyptian.

(2) Another one of these ignores its input and makes all the moves where
Deep Blue beat Garry Kasparov in the famous sixth match.
https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2

(3) An infinite subset of the *remaining subsets* ignores its input and
returns each element of the set of integers, thus one of them returns 1
and another returns 0, this one is called the *wild guess halt decider*

(4) One of these implements the algorithm of my simulating halt decider
https://liarparadox.org/2022_09_07.zip

When it is the job of the halt decider to correctly predict whether or
not its correct and complete simulation of its input would halt even the
*wild guess halt decider* element of subset (3) is correct:

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

Because the *wild guess halt decider* is correct then when my original
design also returns 0 it is also correct.

Because my SHD correctly matches a correct non-halting behavior pattern
that correctly predicts that its correct and complete simulation of its
input would never halt my design does implement a correct simulating
halt decider (SHD).

> You still seem to think that if you are clever enough, and careful enough, then you can write an Hx which will do a complete and correct simulation of Px, but it is not possible.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Op 08.sep..2022 om 16:01 schreef olcott:
> On 9/8/2022 8:07 AM, Paul N wrote:
>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>
>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>
>> We can easily see that if Hx returns zero then Px halts, and if Hx
>> returns non-zero then Px does not halt. So Hx can never do a complete
>> and correct simulation of Px and return the right answer.
>>
>
> I have told you this at least fifteen times now and you somehow make
> sure to keep forgetting (as if you don't give a rat's ass for the truth
> and only want to disagree even at the expense of the truth):
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> void Infinite_Recursion(int N)
> {
>   Infinite_Recursion(N);
> }
>
> Simulating halt deciders (SHD) never do a complete and correct
> simulation of any non-halting input. Instead they match non-halting
> behavior patterns that predict what the behavior of their input would be
> if they did a complete and correct simulation of this input.
>
> In the case of the infinite set of Hx/Px pairs where some of these pairs
> do a complete and correct simulation of their input, none of these ever
> halt, thus this Hx/Px pair correctly predicts the behavior of the
> correct and complete simulation of its input: (Px, Px)
>
> int Hx(ptr x, ptr y)
> {
>   return 0;
> }
>
> We adapt this correct guessing halt decider into a SHD as I have already
> shown.

Sorry if I don't understand you correctly, but if this simple Hx above
already gives the correct prediction, why did you create a complex
simulating H?

On 9/8/2022 11:01 AM, Fred. Zwarts wrote:
> Op 08.sep..2022 om 16:01 schreef olcott:
>> On 9/8/2022 8:07 AM, Paul N wrote:
>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>
>>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>>
>>> We can easily see that if Hx returns zero then Px halts, and if Hx
>>> returns non-zero then Px does not halt. So Hx can never do a complete
>>> and correct simulation of Px and return the right answer.
>>>
>>
>> I have told you this at least fifteen times now and you somehow make
>> sure to keep forgetting (as if you don't give a rat's ass for the
>> truth and only want to disagree even at the expense of the truth):
>>
>> void Infinite_Loop()
>> {
>>    HERE: goto HERE;
>> }
>>
>> void Infinite_Recursion(int N)
>> {
>>    Infinite_Recursion(N);
>> }
>>
>> Simulating halt deciders (SHD) never do a complete and correct
>> simulation of any non-halting input. Instead they match non-halting
>> behavior patterns that predict what the behavior of their input would
>> be if they did a complete and correct simulation of this input.
>>
>> In the case of the infinite set of Hx/Px pairs where some of these
>> pairs do a complete and correct simulation of their input, none of
>> these ever halt, thus this Hx/Px pair correctly predicts the behavior
>> of the correct and complete simulation of its input: (Px, Px)
>>
>> int Hx(ptr x, ptr y)
>> {
>>    return 0;
>> }
>>
>> We adapt this correct guessing halt decider into a SHD as I have
>> already shown.
>
> Sorry if I don't understand you correctly, but if this simple Hx above
> already gives the correct prediction, why did you create a complex
> simulating H?
>
>

My version has discernment between halting and non halting inputs.
https://liarparadox.org/2022_09_07.zip

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

On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
> On 9/8/2022 8:07 AM, Paul N wrote:
> > On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >
> >> Does any complete and correct simulation of Px by Hx ever stop running?
> >
> > We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
> >
> *We will call this the UTM subset*
> We are discussing the infinite set of Hx/Px pairs.

Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?

> An infinite subset of
> these do a complete and correct simulation of their input.

If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.

> Perhaps you fail to comprehend that all of this subset would remain
> stuck in infinitely recursive simulation such that Px never reaches its
> final state and the simulation never stops, thus Hx never returns any
> value.

This point is moot, there are no pairs in this subset.

> *Of the remaining subsets*
> (1) One of these ignores its input and translates the Lord's prayer into
> ancient Egyptian.
>
> (2) Another one of these ignores its input and makes all the moves where
> Deep Blue beat Garry Kasparov in the famous sixth match.
> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>
> (3) An infinite subset of the *remaining subsets* ignores its input and
> returns each element of the set of integers, thus one of them returns 1
> and another returns 0, this one is called the *wild guess halt decider*

All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.

> (4) One of these implements the algorithm of my simulating halt decider
> https://liarparadox.org/2022_09_07.zip

And this one will be wrong too, see above.

> When it is the job of the halt decider to correctly predict whether or
> not its correct and complete simulation of its input would halt even the
> *wild guess halt decider* element of subset (3) is correct:

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

No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!

> Because the *wild guess halt decider* is correct then when my original
> design also returns 0 it is also correct.

No, the wild guess decider is wrong, and your design is wrong.

> Because my SHD correctly matches a correct non-halting behavior pattern
> that correctly predicts that its correct and complete simulation of its
> input would never halt my design does implement a correct simulating
> halt decider (SHD).

You've told us numerous times that your SHD thinks it has matched a non-halting behaviour for a function which you admit halts.

> > You still seem to think that if you are clever enough, and careful enough, then you can write an Hx which will do a complete and correct simulation of Px, but it is not possible.

Indeed, you still think this, don't you?

On 9/8/2022 3:25 PM, Paul N wrote:
> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
>> On 9/8/2022 8:07 AM, Paul N wrote:
>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>
>>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>>
>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
>>>
>> *We will call this the UTM subset*
>> We are discussing the infinite set of Hx/Px pairs.
>
> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
>
>> An infinite subset of
>> these do a complete and correct simulation of their input.
>
> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
>
>> Perhaps you fail to comprehend that all of this subset would remain
>> stuck in infinitely recursive simulation such that Px never reaches its
>> final state and the simulation never stops, thus Hx never returns any
>> value.
>
> This point is moot, there are no pairs in this subset.
>
>> *Of the remaining subsets*
>> (1) One of these ignores its input and translates the Lord's prayer into
>> ancient Egyptian.
>>
>> (2) Another one of these ignores its input and makes all the moves where
>> Deep Blue beat Garry Kasparov in the famous sixth match.
>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>
>> (3) An infinite subset of the *remaining subsets* ignores its input and
>> returns each element of the set of integers, thus one of them returns 1
>> and another returns 0, this one is called the *wild guess halt decider*
>
> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
>
>> (4) One of these implements the algorithm of my simulating halt decider
>> https://liarparadox.org/2022_09_07.zip
>
> And this one will be wrong too, see above.
>
>> When it is the job of the halt decider to correctly predict whether or
>> not its correct and complete simulation of its input would halt even the
>> *wild guess halt decider* element of subset (3) is correct:
>
>> int Hx(ptr x, ptr y)
>> {
>> return 0;
>> }
>
> No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!

All male humans are humans.

all correct and complete simulations of Px by Hx never halt therefore
any damn thing that says:
"all correct and complete simulations of Px by Hx never halt therefore"
*IS NECESSARILY CORRECT*

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 9/8/22 6:34 PM, olcott wrote:

> All male humans are humans.
>
> all correct and complete simulations of Px by Hx never halt therefore
> any damn thing that says:
> "all correct and complete simulations of Px by Hx never halt therefore"
> *IS NECESSARILY CORRECT*
>
>

And the second statement is nonsense because Px isn't *A* machine, just
like Hx isn't A machine.

Each machine in the Px set can have different behaviors.

Yes, EVERY Px in the set built from the Hx's that do a complete
simulation is non-hatling, but NONE of those Hx ever say that.

But, EVERY Px in the set built from the Hx's that abort there simulation
has NOT been completly simulated by ANY Hx's and when we do completely
simulate it, we see it Halts.

Thus EVERY Hx that stops its simulation and returns the non-halting
answer is wrong.

Just like you are wrong.

And showing you are in ignorant pathological lying idiot.

FAIL.

On 9/8/2022 6:24 PM, Richard Damon wrote:
>
> On 9/8/22 6:34 PM, olcott wrote:
>
>> All male humans are humans.
>>
>> all correct and complete simulations of Px by Hx never halt therefore
>> any damn thing that says:
>> "all correct and complete simulations of Px by Hx never halt
>> therefore" *IS NECESSARILY CORRECT*
>>
>>
>
> And the second statement is nonsense because Px isn't *A* machine, just
> like Hx isn't A machine.
>
> Each machine in the Px set can have different behaviors.
>

That is why I proved that every element of the infinite set of Hx/Px
pairs such that Hx correctly and completely simulates its input Px never
halts. *I named this set the HxPx_UTM set*

Thus any damn thing that claims that the Px elements of the HxPx_UTM set
never halt is necessarily correct.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 9/8/22 8:25 PM, olcott wrote:
> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>
>> On 9/8/22 6:34 PM, olcott wrote:
>>
>>> All male humans are humans.
>>>
>>> all correct and complete simulations of Px by Hx never halt therefore
>>> any damn thing that says:
>>> "all correct and complete simulations of Px by Hx never halt
>>> therefore" *IS NECESSARILY CORRECT*
>>>
>>>
>>
>> And the second statement is nonsense because Px isn't *A* machine,
>> just like Hx isn't A machine.
>>
>> Each machine in the Px set can have different behaviors.
>>
>
> That is why I proved that every element of the infinite set of Hx/Px
> pairs such that Hx correctly and completely simulates its input Px never
> halts. *I named this set the HxPx_UTM set*
>
> Thus any damn thing that claims that the Px elements of the HxPx_UTM set
> never halt is necessarily correct.
>

But you only proved the Px's built on the Hx's that don't answer were
non-halting.

The Px's that are built on Hx's that do answer 0 are proved to be
Halting, and you "Proof" doesn't ever address them by just ASSUMES that
they behave the same, when the don't

You can't prove the behavior or a class of machines by only proving the
behavior on a subclass of them with first proving that they all act the
same.

Since, as you have admitted, the behavior of Px is very much dependent
on the behavior of Hx, the fact that not all your Hx actually behave the
same says you haven't proved anything about those that are built on the
Hx's that return 0

FAIL

You repeated making of this fallacious argument just PROVES YOUR STUPIDITY.

On 9/8/22 12:17 PM, olcott wrote:
> On 9/8/2022 11:01 AM, Fred. Zwarts wrote:
>> Op 08.sep..2022 om 16:01 schreef olcott:
>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>
>>>>> Does any complete and correct simulation of Px by Hx ever stop
>>>>> running?
>>>>
>>>> We can easily see that if Hx returns zero then Px halts, and if Hx
>>>> returns non-zero then Px does not halt. So Hx can never do a
>>>> complete and correct simulation of Px and return the right answer.
>>>>
>>>
>>> I have told you this at least fifteen times now and you somehow make
>>> sure to keep forgetting (as if you don't give a rat's ass for the
>>> truth and only want to disagree even at the expense of the truth):
>>>
>>> void Infinite_Loop()
>>> {
>>>    HERE: goto HERE;
>>> }
>>>
>>> void Infinite_Recursion(int N)
>>> {
>>>    Infinite_Recursion(N);
>>> }
>>>
>>> Simulating halt deciders (SHD) never do a complete and correct
>>> simulation of any non-halting input. Instead they match non-halting
>>> behavior patterns that predict what the behavior of their input would
>>> be if they did a complete and correct simulation of this input.
>>>
>>> In the case of the infinite set of Hx/Px pairs where some of these
>>> pairs do a complete and correct simulation of their input, none of
>>> these ever halt, thus this Hx/Px pair correctly predicts the behavior
>>> of the correct and complete simulation of its input: (Px, Px)
>>>
>>> int Hx(ptr x, ptr y)
>>> {
>>>    return 0;
>>> }
>>>
>>> We adapt this correct guessing halt decider into a SHD as I have
>>> already shown.
>>
>> Sorry if I don't understand you correctly, but if this simple Hx above
>> already gives the correct prediction, why did you create a complex
>> simulating H?
>>
>>
>
> My version has discernment between halting and non halting inputs.
> https://liarparadox.org/2022_09_07.zip
>

No, it doesn't, as it assumes ALL H's are non-answering, even if they
will answer in finite time.

FAIL.

On 9/8/22 11:50 AM, olcott wrote:
> On 9/8/2022 8:07 AM, Paul N wrote:
>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>
>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>
>> We can easily see that if Hx returns zero then Px halts, and if Hx
>> returns non-zero then Px does not halt. So Hx can never do a complete
>> and correct simulation of Px and return the right answer.
>>
>
> *We will call this the UTM subset*
> We are discussing the infinite set of Hx/Px pairs. An infinite subset of
> these do a complete and correct simulation of their input.
>
> Perhaps you fail to comprehend that all of this subset would remain
> stuck in infinitely recursive simulation such that Px never reaches its
> final state and the simulation never stops, thus Hx never returns any
> value.
>
> *Of the remaining subsets*
> (1) One of these ignores its input and translates the Lord's prayer into
> ancient Egyptian.
>
> (2) Another one of these ignores its input and makes all the moves where
> Deep Blue beat Garry Kasparov in the famous sixth match.
> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>
> (3) An infinite subset of the *remaining subsets* ignores its input and
> returns each element of the set of integers, thus one of them returns 1
> and another returns 0, this one is called the *wild guess halt decider*
>
> (4) One of these implements the algorithm of my simulating halt decider
> https://liarparadox.org/2022_09_07.zip
>
> When it is the job of the halt decider to correctly predict whether or
> not its correct and complete simulation of its input would halt even the
> *wild guess halt decider* element of subset (3) is correct:
>
> int Hx(ptr x, ptr y)
> {
>   return 0;
> }
>
> Because the *wild guess halt decider* is correct then when my original
> design also returns 0 it is also correct.
>
> Because my SHD correctly matches a correct non-halting behavior pattern
> that correctly predicts that its correct and complete simulation of its
> input would never halt my design does implement a correct simulating
> halt decider (SHD).

Except that the pattern you use has not been proven to be correct, and
even proven that it is sometimes incorrect, says your logic is UNSOUND.

FAIL.

>
>
>> You still seem to think that if you are clever enough, and careful
>> enough, then you can write an Hx which will do a complete and correct
>> simulation of Px, but it is not possible.
>

On 9/8/2022 7:43 PM, Richard Damon wrote:
>
> On 9/8/22 8:25 PM, olcott wrote:
>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>
>>> On 9/8/22 6:34 PM, olcott wrote:
>>>
>>>> All male humans are humans.
>>>>
>>>> all correct and complete simulations of Px by Hx never halt
>>>> therefore any damn thing that says:
>>>> "all correct and complete simulations of Px by Hx never halt
>>>> therefore" *IS NECESSARILY CORRECT*
>>>>
>>>>
>>>
>>> And the second statement is nonsense because Px isn't *A* machine,
>>> just like Hx isn't A machine.
>>>
>>> Each machine in the Px set can have different behaviors.
>>>
>>
>> That is why I proved that every element of the infinite set of Hx/Px
>> pairs such that Hx correctly and completely simulates its input Px
>> never halts. *I named this set the HxPx_UTM set*
>>
>> Thus any damn thing that claims that the Px elements of the HxPx_UTM
>> set never halt is necessarily correct.
>>
>
> But you only proved the Px's built on the Hx's that don't answer were
> non-halting.
That is the entire domain of SHD Hx.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 9/8/22 8:59 PM, olcott wrote:
> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>
>> On 9/8/22 8:25 PM, olcott wrote:
>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>
>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>
>>>>> All male humans are humans.
>>>>>
>>>>> all correct and complete simulations of Px by Hx never halt
>>>>> therefore any damn thing that says:
>>>>> "all correct and complete simulations of Px by Hx never halt
>>>>> therefore" *IS NECESSARILY CORRECT*
>>>>>
>>>>>
>>>>
>>>> And the second statement is nonsense because Px isn't *A* machine,
>>>> just like Hx isn't A machine.
>>>>
>>>> Each machine in the Px set can have different behaviors.
>>>>
>>>
>>> That is why I proved that every element of the infinite set of Hx/Px
>>> pairs such that Hx correctly and completely simulates its input Px
>>> never halts. *I named this set the HxPx_UTM set*
>>>
>>> Thus any damn thing that claims that the Px elements of the HxPx_UTM
>>> set never halt is necessarily correct.
>>>
>>
>> But you only proved the Px's built on the Hx's that don't answer were
>> non-halting.
> That is the entire domain of SHD Hx.
>

Then it isn't a Halt Decider, as a Halt Decider must be able to take in
ALL computations. The "Domain" of a Decider needs to be ALL inputs, and
for a Halting Decider that is the representation of ALL Machines + All
inputs.

And, it says even if you are aiming for partial deciders, none of your
Hx's are answering the "Proof Example" of the impossible program, as
none of your Hx's that do answer can be given the Px built on them.

So, I guess this is just your admission that you have wasted your last
18 years.

Thanks for all the fish.

On 9/8/2022 8:27 PM, Richard Damon wrote:
> On 9/8/22 8:59 PM, olcott wrote:
>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>
>>> On 9/8/22 8:25 PM, olcott wrote:
>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>
>>>>>> All male humans are humans.
>>>>>>
>>>>>> all correct and complete simulations of Px by Hx never halt
>>>>>> therefore any damn thing that says:
>>>>>> "all correct and complete simulations of Px by Hx never halt
>>>>>> therefore" *IS NECESSARILY CORRECT*
>>>>>>
>>>>>>
>>>>>
>>>>> And the second statement is nonsense because Px isn't *A* machine,
>>>>> just like Hx isn't A machine.
>>>>>
>>>>> Each machine in the Px set can have different behaviors.
>>>>>
>>>>
>>>> That is why I proved that every element of the infinite set of Hx/Px
>>>> pairs such that Hx correctly and completely simulates its input Px
>>>> never halts. *I named this set the HxPx_UTM set*
>>>>
>>>> Thus any damn thing that claims that the Px elements of the HxPx_UTM
>>>> set never halt is necessarily correct.
>>>>
>>>
>>> But you only proved the Px's built on the Hx's that don't answer were
>>> non-halting.
>> That is the entire domain of SHD Hx.
>>
>
> Then it isn't a Halt Decider, as a Halt Decider must be able to take in
> ALL computations.

typedef void (*ptr)();

void Px(ptr x)
{ int Halt_Status = Hx(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int Hx(ptr x, ptr y)
{ x(y);
}

Everyone has always said that a halt decider must predict the behavior
of the direct execution of the input thus Hx must base its halt status
decision on the above version of itself.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 9/8/22 10:44 PM, olcott wrote:
> On 9/8/2022 8:27 PM, Richard Damon wrote:
>> On 9/8/22 8:59 PM, olcott wrote:
>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>
>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>
>>>>>>> All male humans are humans.
>>>>>>>
>>>>>>> all correct and complete simulations of Px by Hx never halt
>>>>>>> therefore any damn thing that says:
>>>>>>> "all correct and complete simulations of Px by Hx never halt
>>>>>>> therefore" *IS NECESSARILY CORRECT*
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And the second statement is nonsense because Px isn't *A* machine,
>>>>>> just like Hx isn't A machine.
>>>>>>
>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>
>>>>>
>>>>> That is why I proved that every element of the infinite set of
>>>>> Hx/Px pairs such that Hx correctly and completely simulates its
>>>>> input Px never halts. *I named this set the HxPx_UTM set*
>>>>>
>>>>> Thus any damn thing that claims that the Px elements of the
>>>>> HxPx_UTM set never halt is necessarily correct.
>>>>>
>>>>
>>>> But you only proved the Px's built on the Hx's that don't answer
>>>> were non-halting.
>>> That is the entire domain of SHD Hx.
>>>
>>
>> Then it isn't a Halt Decider, as a Halt Decider must be able to take
>> in ALL computations.
>
>
> typedef void (*ptr)();
>
> void Px(ptr x)
> {
>   int Halt_Status = Hx(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int Hx(ptr x, ptr y)
> {
>   x(y);
> }
>
> Everyone has always said that a halt decider must predict the behavior
> of the direct execution of the input thus Hx must base its halt status
> decision on the above version of itself.
>