On 9/10/2022 12:44 PM, Paul N wrote:
> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1, olcott wrote:
>> On 9/10/2022 11:30 AM, Paul N wrote:
>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1, 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)...
>>>
>>> Nonsense. You've told us many times that Hx does not behave like this. So it is not a correct simulation to pretend that it does.
>>>
>> Hx is not the same as H. As I have told you several times now, the Hx/Px
>> pairs are the infinite set of every encoding of Hx. I am going to stop
>> right here and not proceed to another point until you fully understand
>> and accept this point.
>
> OK then. You are saying that there are infinitely many possible functions Hx, and that of these, infinitely many do a correct simulation of the corresponding Px. I am saying that while here are infinitely many possible functions Hx, none of them do a correct simulation of the corresponding Px.

On 9/10/2022 12:49 PM, Richard Damon wrote:
> On 9/10/22 1:43 PM, olcott wrote:
>> On 9/10/2022 12:36 PM, Richard Damon wrote:
>>> On 9/10/22 1:18 PM, olcott wrote:
>>>> On 9/10/2022 12:06 PM, Richard Damon wrote:
>>>>> On 9/10/22 12:55 PM, olcott wrote:
>>>>>> On 9/10/2022 11:36 AM, Richard Damon wrote:
>>>>>>> On 9/10/22 10:44 AM, olcott 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
>>>>>>>
>>>>>>> But if you ask the question
>>>>>> I don't so it is moot.
>>>>>>
>>>>>> *This is the question*
>>>>>> Does any Px correctly simulated by Hx halt?
>>>>>
>>>>> Then you are admitting your Hx's aren't Halt Deciders!
>>>>>
>>>>> The question for a REAL Halt Decider is does the Machine the input
>>>>> represents Halt, or equivalently, does the UTM simulation of the
>>>>> input given to H halt (not by H, because H can't be a UTM for all
>>>>> input or it isn't a Decider).
>>>>>
>>>>>>
>>>>>> Because the answer to that question is "NO" every Hx that returns
>>>>>> 0 answers it correctly.
>>>>>>
>>>>>
>>>>> So Hx is a correct POOP decider.
>>>>>
>>>>> SO be it.
>>>>
>>>> When a finite string specifies a sequence of moves that reach their
>>>> own final state is the conventional meaning of halting, thus
>>>>
>>>> a finite string that specifies a sequence of moves that NEVER reach
>>>> their own final state is the conventional meaning of NOT halting.
>>>>
>>>
>>> Right, and the interpreter of that finite string is the UTM, since
>>> the decider is unable to simulate the input to NEVER reaching their
>>> own final state.
>>
>> As soon as a simulating halt decider correctly matches a correct
>> infinite behavior pattern it correctly determines that its correctly
>> simulated input cannot possibly reach its own final state.
>>
>>
>
> **CORRECTLY**
>
> Since CORRECTLY is defined based on the UTM simulation of the input,

On 9/10/22 1:59 PM, olcott wrote:
> On 9/10/2022 12:49 PM, Richard Damon wrote:
>> On 9/10/22 1:43 PM, olcott wrote:
>>> On 9/10/2022 12:36 PM, Richard Damon wrote:
>>>> On 9/10/22 1:18 PM, olcott wrote:
>>>>> On 9/10/2022 12:06 PM, Richard Damon wrote:
>>>>>> On 9/10/22 12:55 PM, olcott wrote:
>>>>>>> On 9/10/2022 11:36 AM, Richard Damon wrote:
>>>>>>>> On 9/10/22 10:44 AM, olcott 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
>>>>>>>>
>>>>>>>> But if you ask the question
>>>>>>> I don't so it is moot.
>>>>>>>
>>>>>>> *This is the question*
>>>>>>> Does any Px correctly simulated by Hx halt?
>>>>>>
>>>>>> Then you are admitting your Hx's aren't Halt Deciders!
>>>>>>
>>>>>> The question for a REAL Halt Decider is does the Machine the input
>>>>>> represents Halt, or equivalently, does the UTM simulation of the
>>>>>> input given to H halt (not by H, because H can't be a UTM for all
>>>>>> input or it isn't a Decider).
>>>>>>
>>>>>>>
>>>>>>> Because the answer to that question is "NO" every Hx that returns
>>>>>>> 0 answers it correctly.
>>>>>>>
>>>>>>
>>>>>> So Hx is a correct POOP decider.
>>>>>>
>>>>>> SO be it.
>>>>>
>>>>> When a finite string specifies a sequence of moves that reach their
>>>>> own final state is the conventional meaning of halting, thus
>>>>>
>>>>> a finite string that specifies a sequence of moves that NEVER reach
>>>>> their own final state is the conventional meaning of NOT halting.
>>>>>
>>>>
>>>> Right, and the interpreter of that finite string is the UTM, since
>>>> the decider is unable to simulate the input to NEVER reaching their
>>>> own final state.
>>>
>>> As soon as a simulating halt decider correctly matches a correct
>>> infinite behavior pattern it correctly determines that its correctly
>>> simulated input cannot possibly reach its own final state.
>>>
>>>
>>
>> **CORRECTLY**
>>
>> Since CORRECTLY is defined based on the UTM simulation of the input,
>
> correctly and completely is a subset of correctly.
>
>

On 9/10/2022 1:08 PM, Richard Damon wrote:
> On 9/10/22 1:59 PM, olcott wrote:
>> On 9/10/2022 12:49 PM, Richard Damon wrote:
>>> On 9/10/22 1:43 PM, olcott wrote:
>>>> On 9/10/2022 12:36 PM, Richard Damon wrote:
>>>>> On 9/10/22 1:18 PM, olcott wrote:
>>>>>> On 9/10/2022 12:06 PM, Richard Damon wrote:
>>>>>>> On 9/10/22 12:55 PM, olcott wrote:
>>>>>>>> On 9/10/2022 11:36 AM, Richard Damon wrote:
>>>>>>>>> On 9/10/22 10:44 AM, olcott 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
>>>>>>>>>
>>>>>>>>> But if you ask the question
>>>>>>>> I don't so it is moot.
>>>>>>>>
>>>>>>>> *This is the question*
>>>>>>>> Does any Px correctly simulated by Hx halt?
>>>>>>>
>>>>>>> Then you are admitting your Hx's aren't Halt Deciders!
>>>>>>>
>>>>>>> The question for a REAL Halt Decider is does the Machine the
>>>>>>> input represents Halt, or equivalently, does the UTM simulation
>>>>>>> of the input given to H halt (not by H, because H can't be a UTM
>>>>>>> for all input or it isn't a Decider).
>>>>>>>
>>>>>>>>
>>>>>>>> Because the answer to that question is "NO" every Hx that
>>>>>>>> returns 0 answers it correctly.
>>>>>>>>
>>>>>>>
>>>>>>> So Hx is a correct POOP decider.
>>>>>>>
>>>>>>> SO be it.
>>>>>>
>>>>>> When a finite string specifies a sequence of moves that reach
>>>>>> their own final state is the conventional meaning of halting, thus
>>>>>>
>>>>>> a finite string that specifies a sequence of moves that NEVER
>>>>>> reach their own final state is the conventional meaning of NOT
>>>>>> halting.
>>>>>>
>>>>>
>>>>> Right, and the interpreter of that finite string is the UTM, since
>>>>> the decider is unable to simulate the input to NEVER reaching their
>>>>> own final state.
>>>>
>>>> As soon as a simulating halt decider correctly matches a correct
>>>> infinite behavior pattern it correctly determines that its correctly
>>>> simulated input cannot possibly reach its own final state.
>>>>
>>>>
>>>
>>> **CORRECTLY**
>>>
>>> Since CORRECTLY is defined based on the UTM simulation of the input,
>>
>> correctly and completely is a subset of correctly.
>>
>>
>
> As sets yes, as conditions no. All correctly and completely simulated
> inputs have been correctly simulated.

On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott wrote:
> On 9/10/2022 12:44 PM, Paul N wrote:
> > On Saturday, September 10, 2022 at 5:49:56 PM UTC+1, olcott wrote:
> >> On 9/10/2022 11:30 AM, Paul N wrote:
> >>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1, 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)...
> >>>
> >>> Nonsense. You've told us many times that Hx does not behave like this.. So it is not a correct simulation to pretend that it does.
> >>>
> >> Hx is not the same as H. As I have told you several times now, the Hx/Px
> >> pairs are the infinite set of every encoding of Hx. I am going to stop
> >> right here and not proceed to another point until you fully understand
> >> and accept this point.
> >
> > OK then. You are saying that there are infinitely many possible functions Hx, and that of these, infinitely many do a correct simulation of the corresponding Px. I am saying that while here are infinitely many possible functions Hx, none of them do a correct simulation of the corresponding Px.
>
> int Hx(ptr x, ptr y)
> {
> // An Infinite number of different halting computations can precede this:
> Simulate(x,y);
> return 1;
> }
>
> int main()
> {
> Hx(Px,Px);
> }

On 9/10/2022 2:06 PM, Paul N wrote:
> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott wrote:
>> On 9/10/2022 12:44 PM, Paul N wrote:
>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1, olcott wrote:
>>>> On 9/10/2022 11:30 AM, Paul N wrote:
>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1, 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)...
>>>>>
>>>>> Nonsense. You've told us many times that Hx does not behave like this. So it is not a correct simulation to pretend that it does.
>>>>>
>>>> Hx is not the same as H. As I have told you several times now, the Hx/Px
>>>> pairs are the infinite set of every encoding of Hx. I am going to stop
>>>> right here and not proceed to another point until you fully understand
>>>> and accept this point.
>>>
>>> OK then. You are saying that there are infinitely many possible functions Hx, and that of these, infinitely many do a correct simulation of the corresponding Px. I am saying that while here are infinitely many possible functions Hx, none of them do a correct simulation of the corresponding Px.
>>
>> int Hx(ptr x, ptr y)
>> {
>> // An Infinite number of different halting computations can precede this:
>> Simulate(x,y);
>> return 1;
>> }
>>
>> int main()
>> {
>> Hx(Px,Px);
>> }
>
> You've completely failed to answer any of the questions!
>
> If you accept that of the infinitely many possible functions Hx, none of them do a correct simulation

On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott wrote:
> On 9/10/2022 2:06 PM, Paul N wrote:
> > On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott wrote:
> >> On 9/10/2022 12:44 PM, Paul N wrote:
> >>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1, olcott wrote:
> >>>> On 9/10/2022 11:30 AM, Paul N wrote:
> >>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1, 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)...
> >>>>>
> >>>>> Nonsense. You've told us many times that Hx does not behave like this. So it is not a correct simulation to pretend that it does.
> >>>>>
> >>>> Hx is not the same as H. As I have told you several times now, the Hx/Px
> >>>> pairs are the infinite set of every encoding of Hx. I am going to stop
> >>>> right here and not proceed to another point until you fully understand
> >>>> and accept this point.
> >>>
> >>> OK then. You are saying that there are infinitely many possible functions Hx, and that of these, infinitely many do a correct simulation of the corresponding Px. I am saying that while here are infinitely many possible functions Hx, none of them do a correct simulation of the corresponding Px.
> >>
> >> int Hx(ptr x, ptr y)
> >> {
> >> // An Infinite number of different halting computations can precede this:
> >> Simulate(x,y);
> >> return 1;
> >> }
> >>
> >> int main()
> >> {
> >> Hx(Px,Px);
> >> }
> >
> > You've completely failed to answer any of the questions!
> >
> > If you accept that of the infinitely many possible functions Hx, none of them do a correct simulation
> It is stipulated that I just provided such a function.
> Here it is again named differently:
> int Hx(ptr x, ptr y)
> {
> x86_emulate(x,y);
> return 1;
> }
>
> Hx function that is computationally equivalent to the above:
> int Hx(ptr x, ptr y)
> {
> x(y);
> return 1;
> }

On 9/10/2022 2:44 PM, Paul N wrote:
> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott wrote:
>> On 9/10/2022 2:06 PM, Paul N wrote:
>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott wrote:
>>>> On 9/10/2022 12:44 PM, Paul N wrote:
>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1, olcott wrote:
>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1, 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)...
>>>>>>>
>>>>>>> Nonsense. You've told us many times that Hx does not behave like this. So it is not a correct simulation to pretend that it does.
>>>>>>>
>>>>>> Hx is not the same as H. As I have told you several times now, the Hx/Px
>>>>>> pairs are the infinite set of every encoding of Hx. I am going to stop
>>>>>> right here and not proceed to another point until you fully understand
>>>>>> and accept this point.
>>>>>
>>>>> OK then. You are saying that there are infinitely many possible functions Hx, and that of these, infinitely many do a correct simulation of the corresponding Px. I am saying that while here are infinitely many possible functions Hx, none of them do a correct simulation of the corresponding Px.
>>>>
>>>> int Hx(ptr x, ptr y)
>>>> {
>>>> // An Infinite number of different halting computations can precede this:
>>>> Simulate(x,y);
>>>> return 1;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Hx(Px,Px);
>>>> }
>>>
>>> You've completely failed to answer any of the questions!
>>>
>>> If you accept that of the infinitely many possible functions Hx, none of them do a correct simulation
>> It is stipulated that I just provided such a function.
>> Here it is again named differently:
>> int Hx(ptr x, ptr y)
>> {
>> x86_emulate(x,y);
>> return 1;
>> }
>>
>> Hx function that is computationally equivalent to the above:
>> int Hx(ptr x, ptr y)
>> {
>> x(y);
>> return 1;
>> }
>
> Fair enough. I ask you the questions a second time and you just snip them again. You've provided one function which simply calls another, unshown, function, so we can't have a clue what it does. You've also said it is "computationally equivalent" (whatever that means) to a function which won't return a value. I can only assume that you know full well that no functions provide a correct result for Px and that you are simply trying to bluff. There's no reason to further try to persuade you that you're wrong, you apparently know it already.

On Sat, 10 Sep 2022 15:24:39 -0500
olcott <none-ya@beez-wax.com> wrote:

> On 9/10/2022 2:44 PM, Paul N wrote:
> > On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott wrote:
> >> On 9/10/2022 2:06 PM, Paul N wrote:
> >>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott
> >>> wrote:
> >>>> On 9/10/2022 12:44 PM, Paul N wrote:
> >>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1, olcott
> >>>>> wrote:
> >>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
> >>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1, 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)...
> >>>>>>>
> >>>>>>> Nonsense. You've told us many times that Hx does not behave
> >>>>>>> like this. So it is not a correct simulation to pretend that
> >>>>>>> it does.
> >>>>>> Hx is not the same as H. As I have told you several times now,
> >>>>>> the Hx/Px pairs are the infinite set of every encoding of Hx.
> >>>>>> I am going to stop right here and not proceed to another point
> >>>>>> until you fully understand and accept this point.
> >>>>>
> >>>>> OK then. You are saying that there are infinitely many possible
> >>>>> functions Hx, and that of these, infinitely many do a correct
> >>>>> simulation of the corresponding Px. I am saying that while here
> >>>>> are infinitely many possible functions Hx, none of them do a
> >>>>> correct simulation of the corresponding Px.
> >>>>
> >>>> int Hx(ptr x, ptr y)
> >>>> {
> >>>> // An Infinite number of different halting computations can
> >>>> precede this: Simulate(x,y);
> >>>> return 1;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Hx(Px,Px);
> >>>> }
> >>>
> >>> You've completely failed to answer any of the questions!
> >>>
> >>> If you accept that of the infinitely many possible functions Hx,
> >>> none of them do a correct simulation
> >> It is stipulated that I just provided such a function.
> >> Here it is again named differently:
> >> int Hx(ptr x, ptr y)
> >> {
> >> x86_emulate(x,y);
> >> return 1;
> >> }
> >>
> >> Hx function that is computationally equivalent to the above:
> >> int Hx(ptr x, ptr y)
> >> {
> >> x(y);
> >> return 1;
> >> }
> >
> > Fair enough. I ask you the questions a second time and you just
> > snip them again. You've provided one function which simply calls
> > another, unshown, function, so we can't have a clue what it does.
> > You've also said it is "computationally equivalent" (whatever that
> > means) to a function which won't return a value. I can only assume
> > that you know full well that no functions provide a correct result
> > for Px and that you are simply trying to bluff. There's no reason
> > to further try to persuade you that you're wrong, you apparently
> > know it already.
>
> So you still don't understand that all simulating halt deciders
> PREDICT that their complete simulation of their input would never
> reach the final state of this simulated input without actually
> performing a complete simulation of this non-terminating input?
>
> *I have told you this dozens of times and you still don't get it*?
>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> int main()
> {
> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> }
>
> _Infinite_Loop()
> [00001102](01) 55 push ebp
> [00001103](02) 8bec mov ebp,esp
> [00001105](02) ebfe jmp 00001105
> [00001107](01) 5d pop ebp
> [00001108](01) c3 ret
> Size in bytes:(0007) [00001108]
>
> H0: Begin Simulation Execution Trace Stored at:211fac
> [00001102][00211f9c][00211fa0] 55 push ebp
> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> H0: Infinite Loop Detected Simulation Stopped
>
> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF _Infinite_Loop() YET
> STILL CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION WOULD NEVER
> HALT.

On 9/10/2022 3:29 PM, Mr Flibble wrote:
> On Sat, 10 Sep 2022 15:24:39 -0500
> olcott <none-ya@beez-wax.com> wrote:
>
>> On 9/10/2022 2:44 PM, Paul N wrote:
>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott wrote:
>>>> On 9/10/2022 2:06 PM, Paul N wrote:
>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott
>>>>> wrote:
>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1, olcott
>>>>>>> wrote:
>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1, 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)...
>>>>>>>>>
>>>>>>>>> Nonsense. You've told us many times that Hx does not behave
>>>>>>>>> like this. So it is not a correct simulation to pretend that
>>>>>>>>> it does.
>>>>>>>> Hx is not the same as H. As I have told you several times now,
>>>>>>>> the Hx/Px pairs are the infinite set of every encoding of Hx.
>>>>>>>> I am going to stop right here and not proceed to another point
>>>>>>>> until you fully understand and accept this point.
>>>>>>>
>>>>>>> OK then. You are saying that there are infinitely many possible
>>>>>>> functions Hx, and that of these, infinitely many do a correct
>>>>>>> simulation of the corresponding Px. I am saying that while here
>>>>>>> are infinitely many possible functions Hx, none of them do a
>>>>>>> correct simulation of the corresponding Px.
>>>>>>
>>>>>> int Hx(ptr x, ptr y)
>>>>>> {
>>>>>> // An Infinite number of different halting computations can
>>>>>> precede this: Simulate(x,y);
>>>>>> return 1;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Hx(Px,Px);
>>>>>> }
>>>>>
>>>>> You've completely failed to answer any of the questions!
>>>>>
>>>>> If you accept that of the infinitely many possible functions Hx,
>>>>> none of them do a correct simulation
>>>> It is stipulated that I just provided such a function.
>>>> Here it is again named differently:
>>>> int Hx(ptr x, ptr y)
>>>> {
>>>> x86_emulate(x,y);
>>>> return 1;
>>>> }
>>>>
>>>> Hx function that is computationally equivalent to the above:
>>>> int Hx(ptr x, ptr y)
>>>> {
>>>> x(y);
>>>> return 1;
>>>> }
>>>
>>> Fair enough. I ask you the questions a second time and you just
>>> snip them again. You've provided one function which simply calls
>>> another, unshown, function, so we can't have a clue what it does.
>>> You've also said it is "computationally equivalent" (whatever that
>>> means) to a function which won't return a value. I can only assume
>>> that you know full well that no functions provide a correct result
>>> for Px and that you are simply trying to bluff. There's no reason
>>> to further try to persuade you that you're wrong, you apparently
>>> know it already.
>>
>> So you still don't understand that all simulating halt deciders
>> PREDICT that their complete simulation of their input would never
>> reach the final state of this simulated input without actually
>> performing a complete simulation of this non-terminating input?
>>
>> *I have told you this dozens of times and you still don't get it*?
>>
>> void Infinite_Loop()
>> {
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>> }
>>
>> _Infinite_Loop()
>> [00001102](01) 55 push ebp
>> [00001103](02) 8bec mov ebp,esp
>> [00001105](02) ebfe jmp 00001105
>> [00001107](01) 5d pop ebp
>> [00001108](01) c3 ret
>> Size in bytes:(0007) [00001108]
>>
>> H0: Begin Simulation Execution Trace Stored at:211fac
>> [00001102][00211f9c][00211fa0] 55 push ebp
>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>> H0: Infinite Loop Detected Simulation Stopped
>>
>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF _Infinite_Loop() YET
>> STILL CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION WOULD NEVER
>> HALT.
>
> Detecting non-halting is different to aborting a simulation because the
> decider is incorrectly designed using recursion.
>
> /Flibble

On 9/10/2022 3:29 PM, Mr Flibble wrote:
> On Sat, 10 Sep 2022 15:24:39 -0500
> olcott <none-ya@beez-wax.com> wrote:
>
>> On 9/10/2022 2:44 PM, Paul N wrote:
>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott wrote:
>>>> On 9/10/2022 2:06 PM, Paul N wrote:
>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott
>>>>> wrote:
>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1, olcott
>>>>>>> wrote:
>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1, 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)...
>>>>>>>>>
>>>>>>>>> Nonsense. You've told us many times that Hx does not behave
>>>>>>>>> like this. So it is not a correct simulation to pretend that
>>>>>>>>> it does.
>>>>>>>> Hx is not the same as H. As I have told you several times now,
>>>>>>>> the Hx/Px pairs are the infinite set of every encoding of Hx.
>>>>>>>> I am going to stop right here and not proceed to another point
>>>>>>>> until you fully understand and accept this point.
>>>>>>>
>>>>>>> OK then. You are saying that there are infinitely many possible
>>>>>>> functions Hx, and that of these, infinitely many do a correct
>>>>>>> simulation of the corresponding Px. I am saying that while here
>>>>>>> are infinitely many possible functions Hx, none of them do a
>>>>>>> correct simulation of the corresponding Px.
>>>>>>
>>>>>> int Hx(ptr x, ptr y)
>>>>>> {
>>>>>> // An Infinite number of different halting computations can
>>>>>> precede this: Simulate(x,y);
>>>>>> return 1;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Hx(Px,Px);
>>>>>> }
>>>>>
>>>>> You've completely failed to answer any of the questions!
>>>>>
>>>>> If you accept that of the infinitely many possible functions Hx,
>>>>> none of them do a correct simulation
>>>> It is stipulated that I just provided such a function.
>>>> Here it is again named differently:
>>>> int Hx(ptr x, ptr y)
>>>> {
>>>> x86_emulate(x,y);
>>>> return 1;
>>>> }
>>>>
>>>> Hx function that is computationally equivalent to the above:
>>>> int Hx(ptr x, ptr y)
>>>> {
>>>> x(y);
>>>> return 1;
>>>> }
>>>
>>> Fair enough. I ask you the questions a second time and you just
>>> snip them again. You've provided one function which simply calls
>>> another, unshown, function, so we can't have a clue what it does.
>>> You've also said it is "computationally equivalent" (whatever that
>>> means) to a function which won't return a value. I can only assume
>>> that you know full well that no functions provide a correct result
>>> for Px and that you are simply trying to bluff. There's no reason
>>> to further try to persuade you that you're wrong, you apparently
>>> know it already.
>>
>> So you still don't understand that all simulating halt deciders
>> PREDICT that their complete simulation of their input would never
>> reach the final state of this simulated input without actually
>> performing a complete simulation of this non-terminating input?
>>
>> *I have told you this dozens of times and you still don't get it*?
>>
>> void Infinite_Loop()
>> {
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>> }
>>
>> _Infinite_Loop()
>> [00001102](01) 55 push ebp
>> [00001103](02) 8bec mov ebp,esp
>> [00001105](02) ebfe jmp 00001105
>> [00001107](01) 5d pop ebp
>> [00001108](01) c3 ret
>> Size in bytes:(0007) [00001108]
>>
>> H0: Begin Simulation Execution Trace Stored at:211fac
>> [00001102][00211f9c][00211fa0] 55 push ebp
>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>> H0: Infinite Loop Detected Simulation Stopped
>>
>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF _Infinite_Loop() YET
>> STILL CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION WOULD NEVER
>> HALT.
>
> Detecting non-halting is different to aborting a simulation because the
> decider is incorrectly designed using recursion.
>
> /Flibble
>
>

On 9/10/22 2:22 PM, olcott wrote:
> On 9/10/2022 1:08 PM, Richard Damon wrote:
>> On 9/10/22 1:59 PM, olcott wrote:
>>> On 9/10/2022 12:49 PM, Richard Damon wrote:
>>>> On 9/10/22 1:43 PM, olcott wrote:
>>>>> On 9/10/2022 12:36 PM, Richard Damon wrote:
>>>>>> On 9/10/22 1:18 PM, olcott wrote:
>>>>>>> On 9/10/2022 12:06 PM, Richard Damon wrote:
>>>>>>>> On 9/10/22 12:55 PM, olcott wrote:
>>>>>>>>> On 9/10/2022 11:36 AM, Richard Damon wrote:
>>>>>>>>>> On 9/10/22 10:44 AM, olcott 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
>>>>>>>>>>
>>>>>>>>>> But if you ask the question
>>>>>>>>> I don't so it is moot.
>>>>>>>>>
>>>>>>>>> *This is the question*
>>>>>>>>> Does any Px correctly simulated by Hx halt?
>>>>>>>>
>>>>>>>> Then you are admitting your Hx's aren't Halt Deciders!
>>>>>>>>
>>>>>>>> The question for a REAL Halt Decider is does the Machine the
>>>>>>>> input represents Halt, or equivalently, does the UTM simulation
>>>>>>>> of the input given to H halt (not by H, because H can't be a UTM
>>>>>>>> for all input or it isn't a Decider).
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because the answer to that question is "NO" every Hx that
>>>>>>>>> returns 0 answers it correctly.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So Hx is a correct POOP decider.
>>>>>>>>
>>>>>>>> SO be it.
>>>>>>>
>>>>>>> When a finite string specifies a sequence of moves that reach
>>>>>>> their own final state is the conventional meaning of halting, thus
>>>>>>>
>>>>>>> a finite string that specifies a sequence of moves that NEVER
>>>>>>> reach their own final state is the conventional meaning of NOT
>>>>>>> halting.
>>>>>>>
>>>>>>
>>>>>> Right, and the interpreter of that finite string is the UTM, since
>>>>>> the decider is unable to simulate the input to NEVER reaching
>>>>>> their own final state.
>>>>>
>>>>> As soon as a simulating halt decider correctly matches a correct
>>>>> infinite behavior pattern it correctly determines that its
>>>>> correctly simulated input cannot possibly reach its own final state.
>>>>>
>>>>>
>>>>
>>>> **CORRECTLY**
>>>>
>>>> Since CORRECTLY is defined based on the UTM simulation of the input,
>>>
>>> correctly and completely is a subset of correctly.
>>>
>>>
>>
>> As sets yes, as conditions no. All correctly and completely simulated
>> inputs have been correctly simulated.
>
> Mike already corrected you on this: When 1 to N instructions have been
> correctly simulated** then 1 to N instructions have been correctly
> simulated.
>
>