On 9/9/2022 1:36 PM, Paul N wrote:
> On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott wrote:
>> On 9/9/2022 12:49 PM, Paul N wrote:
>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott wrote:
>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
>>>>>> 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*
>>>>>
>>>>> Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?
>>>
>>>> So you don't understand the above point that applies to every program
>>>> that return 0?
>>>
>>> If you mean the four lines just above, no, I am not clear what they say. I'm not even sure you know what they say. I think you need some words after the second "therefore" to make them make sense.
>>>
>>
>> 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));
>> }
>> The code for Px is fully specified. The code for Hx is the infinite set
>> of every C function that takes a pair of ptr arguments. These arguments
>> can be ignored, summed together, multiplied together, simulated, or
>> anything else. One element of Hx ignores its arguments, translates the
>> Lord's prayer into ancient Egyptian and returns 56.
>>
>> A subset of these C functions perform a correct partial or complete
>> simulation of their input. In none of the elements of this set does Px
>> ever reach its final state.
>>
>> A subset of the original set return a value of 0, which turns out to be
>> the correct answer to the question:
>>
>> Does there exist any element of the infinite set of Hx/Px pairs such
>> that Px correctly simulated by Hx reaches the final state of Px?
>>
>> One element of the prior set correctly matches a correct infinite
>> behavior pattern, aborts the simulation of its input on the basis and
>> returns 0.
>
> You've quoted the code of Px above, are you really incapable of actually understanding it? Let's see:
>
> void Px(ptr x)
> {
> int Halt_Status = Hx(x, x); // you say that Hx(x, x) returns 0, so Halt_Status is set to zero
>> if (Halt_Status) // Halt_Status is zero, so this "if" fails...
>> HERE: goto HERE; // ... and so this line is not executed ...
>> return; // ... and we get to here.
>> }
>
> So Px halts. There is no infinite behaviour pattern.

I have to update my last reply because I realized that it was not
accurate. I really only want an honest dialogue and I incorrectly said
that you made a mistake that you did not make.

A simulating halt decider (SHD) only reports on the behavior of what its
complete and correct simulation of its input would be, it never reports
on the actual behavior of what its partial simulation is.

If a SHD reported on whether or not its input stopped running then in
those cases where the simulated input stopped on its own and those cases
where the simulation was aborted the simulated input stopped running.
This derives a correct halt decider with no discernment every input is
reported to stop running.

To allow a SHD to have discernment it answers a different question:
Does any correct simulation of its input reach the final state of this
input?

This question also answers the classic HP question:
Does the direct execution of your input halt?

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

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