On 9/10/2022 10:06 AM, Mr Flibble wrote:
> On Sat, 10 Sep 2022 09:44:34 -0500
> olcott <none-ya@beez-wax.com> wrote:
>
>> On 9/10/2022 9:36 AM, Richard Damon wrote:
>>> On 9/10/22 10:16 AM, olcott wrote:
>>>> On 9/10/2022 9:12 AM, Richard Damon wrote:
>>>>> On 9/10/22 9:58 AM, olcott wrote:
>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1, olcott wrote:
>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1, olcott
>>>>>>>>> wrote:
>>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> Thank you for this. Yes, I was saying that if Hx(Px, Px)
>>>>>>>>> returns 0 then Px halts.
>>>>>>>>>
>>>>>>>>>> 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?
>>>>>>>>>
>>>>>>>>> The snag is that Hx must always give the wrong answer for Px,
>>>>>>>> That is not true. Of the infinite set of Hx that correctly
>>>>>>>> simulate Px
>>>>>>>> none ever reach the final state of Px.
>>>>>>>
>>>>>>> I assume when you say "Hx that correctly simulate Px" you're
>>>>>>> not just talking about what Hx does internally, you are also
>>>>>>> saying that Hx returns the correct answer in a finite time. (If
>>>>>>> this is not what you mean then please spell out what you do
>>>>>>> mean more clearly.)
>>>>>>>
>>>>>>> As I've said before, there is not an infinite set of Hx that
>>>>>>> correctly simulate Px. EVERY Hx gets its corresponding Px wrong.
>>>>>>>
>>>>>>>> Every simulating halt decider must only predict the behavior
>>>>>>>> of what its
>>>>>>>> correct and complete simulation of its input would be and the
>>>>>>>> must not
>>>>>>>> report on the actual behavior of its partial simulation.
>>>>>>>> void Infinite_Loop()
>>>>>>>> {
>>>>>>>> HERE: goto HERE;
>>>>>>>> }
>>>>>>>> When H0 reports that its correct and complete simulation of
>>>>>>>> its input Infinite_Loop() would never reach the final state of
>>>>>>>> this simulated input it has a sound basis.
>>>>>>>
>>>>>>> Yes, there's no problem with this function and no reason why Hx
>>>>>>> need get it wrong. You've said that you have written an Hx
>>>>>>> which correctly handles this case and I have no reason to doubt
>>>>>>> this.
>>>>>>>
>>>>>>> The problem with Px is that it necessarily does the opposite of
>>>>>>> what Hx predicts it will.
>>>>>>
>>>>>> You must have not been paying hardly and attention at all.
>>>>>>
>>>>>> *The correct and complete simulation of the input to Hx(P,P) by
>>>>>> Hx* (a) Hx(P,P) simulates P(P) that calls a simulated Hx(P,P)
>>>>>> (b) that simulates P(P) that calls a simulated Hx(P,P)
>>>>>> (c) that simulates P(P) that calls a simulated Hx(P,P)
>>>>>> (d) that simulates P(P) that calls a simulated Hx(P,P)...
>>>>>>
>>>>>> No correctly simulated Px ever reaches the "if" statement that
>>>>>> tests the return value from Hx.
>>>>>>
>>>>>> *This fully operational code proves that*
>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>
>>>>>>
>>>>>>> Look at the code for Px - it's very short and simple. Work out
>>>>>>> what Px will do if Hx returns 0. Then work out what Px will do
>>>>>>> if Hx returns non-zero. Hx is wrong every time, isn't it?
>>>>>>>
>>>>>>> Another poster gave you an example where he explained the rules
>>>>>>> of a game to you but you could not predict what he would do,
>>>>>>> because the rules were that he would do the opposite of what
>>>>>>> you said. It's exactly the same situation here.
>>>>>>>
>>>>>>>> When Hx reports that its correct and complete simulation of
>>>>>>>> its input Px would never reach the final state of this
>>>>>>>> simulated input it has a sound basis.
>>>>>>>>
>>>>>>>> In neither case does it matter that neither H0 not Hx actually
>>>>>>>> performs
>>>>>>>> a correct and complete simulation of its input.
>>>>>>>>> that is how Px is set up. You can't get round it just by
>>>>>>>>> being very very careful about how Hx works.
>>>>>>>>>
>>>>>>>>>> This question also answers the classic HP question:
>>>>>>>>>> Does the direct execution of your input halt?
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>> x(y);
>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Yes, if x(y) halts then Hx can identify this (I assume you
>>>>>>>>> meant to include "return 1;" or the like at the end).
>>>>>>
>>>>>> The problem is that it never returns a value if x(y) does not
>>>>>> halt. Worse still, the user doesn't know whether Hx is running
>>>>>> forever (meaning x(y) will not halt) or whether it just hasn't
>>>>>> finished yet.
>>>>>>
>>>>>> Anyone that is competent at these things knows that the above
>>>>>> Hx/Px combination remains infinitely recursive forever. When a
>>>>>> halt decider Px correctly predicts that it is necessarily
>>>>>> correct.
>>>>>>
>>>>>
>>>>> Right *THAT* Hx/Px pair has Px being non-halting, but Hx never
>>>>> gives the answer.
>>>>
>>>> Zero elements of the infinite set of Hx/Px pairs where Hx
>>>> correctly simulates its input reach their final state, thus zero
>>>> Px elements halt, thus every Hx that returns 0 is correct.
>>>>
>>>>
>>>
>>> Bad logic.
>>>
>>
>> When we ask:
>> Are male humans human? the answer YES
>> Does any Px correctly simulated by Hx halt? the answer NO
>
> The answer is YES:
>
> void Px(void (*x)())
> {
> (void) Hx(x, x);
> return;
> }
>

That is not an example of a Px that when correctly simulated by Hx
halts, incorrect simulations do not count.

When the simulated Px invokes the simulated Hx this requires:
(a) This simulated Hx to simulate Px again.
(b) An outer Hx to abort its simulation of Px.

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