On 9/10/2022 7:56 PM, Mr Flibble wrote:
> On Sat, 10 Sep 2022 15:55:35 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> 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
>>>
>>>
>>
>> *It* is easy to verify that HH(PP,PP) is correctly designed to do
>> recursive simulation. This was the hardest part of the entire design.
>> https://liarparadox.org/2022_09_07.zip
>>
>> Each emulation requires its own process context including its own
>> stack space.
>
> Recursive simulation is the wrong approach as a halting decider is
> supposed to always return a result to its caller.

On 9/10/22 9:00 PM, olcott wrote:
> On 9/10/2022 7:23 PM, Richard Damon wrote:
>> On 9/10/22 8:05 PM, olcott wrote:
>>> On 9/10/2022 6:43 PM, Mr Flibble wrote:
>>>> On Sat, 10 Sep 2022 18:27:34 -0500
>>>> olcott <polcott2@gmail.com> wrote:
>>>>
>>>>> On 9/10/2022 5:55 PM, Richard Damon wrote:
>>>>>> On 9/10/22 6:31 PM, olcott wrote:
>>>>>>> On 9/10/2022 5:24 PM, Richard Damon wrote:
>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, if you simulate for N instructions, and it stops after a
>>>>>>>> higher number M, then it is a HALTING simulstion.
>>>>>>>>
>>>>>>>> You Hx's are ALL wrong (if they give an answer at all) about the
>>>>>>>> behavior of their Px.
>>>>>>>
>>>>>>> Since you already know that no Px correctly and completely
>>>>>>> simulated by Hx reaches its final state you know that these Px
>>>>>>> elements of the Hx/Px pairs are non-halting.
>>>>>>
>>>>>> Yes, the Px that are completely simulated by their Hx are
>>>>>> non-halting, but none of those Hx ever give that answer, so those
>>>>>> Hx were wrong.
>>>>>
>>>>> It is incorrect to say that these Hx are wrong because there is no
>>>>> assumption that Hx is a decider.
>>>>
>>>> The 'H' is 'Hx' stands for "halting" ergo the assumption is that Hx is
>>>> attempting to be a decider.  Don't use 'H' if what you are talking
>>>> about isn't a halting decider (this applies to your SHD too which
>>>> simply doesn't work as a halting decider).
>>>>
>>>> /Flibble
>>>>
>>>
>>> In order to prove that a subset of Hx of the Hx/Px pairs are correct
>>> halt deciders I had to show that the every element of the infinite
>>> set of correct simulations of Px by Hx never reach the final state of
>>> the simulated Px.
>>>
>>> If no X are Y then anything reporting that no X are Y is correct.
>>>
>>
>> Since the subset that correctly simulate their inputs do NOT get the
>> same inputs as the subset that answers,
>
> One single Hx simultaneously decides for an infinite set of Hx/Px pairs
> that is why I switched to sets of Hx. No more switch-a-roo for you.
>
>

On 9/10/22 9:02 PM, olcott wrote:
> On 9/10/2022 7:42 PM, Richard Damon wrote:
>> On 9/10/22 7:27 PM, olcott wrote:
>>> On 9/10/2022 5:55 PM, Richard Damon wrote:
>>>> On 9/10/22 6:31 PM, olcott wrote:
>>>>> On 9/10/2022 5:24 PM, Richard Damon wrote:
>>>>>> 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.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> So, if you simulate for N instructions, and it stops after a
>>>>>> higher number M, then it is a HALTING simulstion.
>>>>>>
>>>>>> You Hx's are ALL wrong (if they give an answer at all) about the
>>>>>> behavior of their Px.
>>>>>
>>>>> Since you already know that no Px correctly and completely
>>>>> simulated by Hx reaches its final state you know that these Px
>>>>> elements of the Hx/Px pairs are non-halting.
>>>>>
>>>>
>>>> Yes, the Px that are completely simulated by their Hx are
>>>> non-halting, but none of those Hx ever give that answer, so those Hx
>>>> were wrong.
>>>>
>>>
>>> It is incorrect to say that these Hx are wrong because there is no
>>> assumption that Hx is a decider.
>>>
>>>> The Hx that DO give the answer of 0 for Hx(Px,Px) are
>>>
>>> *Correct within the definition of a simulating halt decider*
>>> A simulating halt decider correctly determines that its correct
>>> simulation of 0 to ∞ instructions of its simulated input would never
>>> reach the final state of this simulated input.
>>>
>>>
>>
>> But only the GIVEN Hx is simulating the given input,
>
> No not at all. A given Hx correctly decides for every element of an
> infinite set of Hx/Px pairs. That eliminates your switch-a-roo dodge.
>

On 9/10/2022 8:31 PM, Richard Damon wrote:
> On 9/10/22 9:00 PM, olcott wrote:
>> On 9/10/2022 7:23 PM, Richard Damon wrote:
>>> On 9/10/22 8:05 PM, olcott wrote:
>>>> On 9/10/2022 6:43 PM, Mr Flibble wrote:
>>>>> On Sat, 10 Sep 2022 18:27:34 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 9/10/2022 5:55 PM, Richard Damon wrote:
>>>>>>> On 9/10/22 6:31 PM, olcott wrote:
>>>>>>>> On 9/10/2022 5:24 PM, Richard Damon wrote:
>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, if you simulate for N instructions, and it stops after a
>>>>>>>>> higher number M, then it is a HALTING simulstion.
>>>>>>>>>
>>>>>>>>> You Hx's are ALL wrong (if they give an answer at all) about the
>>>>>>>>> behavior of their Px.
>>>>>>>>
>>>>>>>> Since you already know that no Px correctly and completely
>>>>>>>> simulated by Hx reaches its final state you know that these Px
>>>>>>>> elements of the Hx/Px pairs are non-halting.
>>>>>>>
>>>>>>> Yes, the Px that are completely simulated by their Hx are
>>>>>>> non-halting, but none of those Hx ever give that answer, so those
>>>>>>> Hx were wrong.
>>>>>>
>>>>>> It is incorrect to say that these Hx are wrong because there is no
>>>>>> assumption that Hx is a decider.
>>>>>
>>>>> The 'H' is 'Hx' stands for "halting" ergo the assumption is that Hx is
>>>>> attempting to be a decider.  Don't use 'H' if what you are talking
>>>>> about isn't a halting decider (this applies to your SHD too which
>>>>> simply doesn't work as a halting decider).
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> In order to prove that a subset of Hx of the Hx/Px pairs are correct
>>>> halt deciders I had to show that the every element of the infinite
>>>> set of correct simulations of Px by Hx never reach the final state
>>>> of the simulated Px.
>>>>
>>>> If no X are Y then anything reporting that no X are Y is correct.
>>>>
>>>
>>> Since the subset that correctly simulate their inputs do NOT get the
>>> same inputs as the subset that answers,
>>
>> One single Hx simultaneously decides for an infinite set of Hx/Px
>> pairs that is why I switched to sets of Hx. No more switch-a-roo for you.
>>
>>
>
> No, because a given Hx only has a single input, the Px built on it.
>

On Sat, 10 Sep 2022 20:16:29 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/10/2022 7:56 PM, Mr Flibble wrote:
> > On Sat, 10 Sep 2022 15:55:35 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> 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
> >>>
> >>>
> >>
> >> *It* is easy to verify that HH(PP,PP) is correctly designed to do
> >> recursive simulation. This was the hardest part of the entire
> >> design. https://liarparadox.org/2022_09_07.zip
> >>
> >> Each emulation requires its own process context including its own
> >> stack space.
> >
> > Recursive simulation is the wrong approach as a halting decider is
> > supposed to always return a result to its caller.
>
> None-the-less some inputs specify recursive simulation thus correctly
> simulating these inputs requires recursive simulation.
>
> If the computer science definition of a decider contradicts the
> computer science definition of recursion then at least one of these
> definitions is incorrect.
>
> As a side effect of the months that I spent getting rid of the need
> for static local memory (so that my simulating halt decider could
> become a pure function of its inputs) I was also able to abort the
> simulation of P before P actually invokes a second instance of H.
>
> Every time that H is invoked with the same inputs it returns the same
> value to its caller. Anyone that believes that a function that was
> never invoked must still return a value MUST BE NUTS !
>
> > The Flibble
> > Signaling Halt Decider (tm) is a simulating halt decider that does
> > not rely on recursion.
> >
> > /Flibble
> >
>
> So it cannot process this input:
>
> void Infinite_Recursion(int N)
> {
> Infinite_Recursion(N);
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Infinite_Recursion, 0x777));
> }

On 9/11/22 12:45 AM, olcott wrote:
> On 9/10/2022 8:31 PM, Richard Damon wrote:
>> On 9/10/22 9:00 PM, olcott wrote:
>>> On 9/10/2022 7:23 PM, Richard Damon wrote:
>>>> On 9/10/22 8:05 PM, olcott wrote:
>>>>> On 9/10/2022 6:43 PM, Mr Flibble wrote:
>>>>>> On Sat, 10 Sep 2022 18:27:34 -0500
>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>
>>>>>>> On 9/10/2022 5:55 PM, Richard Damon wrote:
>>>>>>>> On 9/10/22 6:31 PM, olcott wrote:
>>>>>>>>> On 9/10/2022 5:24 PM, Richard Damon wrote:
>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, if you simulate for N instructions, and it stops after a
>>>>>>>>>> higher number M, then it is a HALTING simulstion.
>>>>>>>>>>
>>>>>>>>>> You Hx's are ALL wrong (if they give an answer at all) about the
>>>>>>>>>> behavior of their Px.
>>>>>>>>>
>>>>>>>>> Since you already know that no Px correctly and completely
>>>>>>>>> simulated by Hx reaches its final state you know that these Px
>>>>>>>>> elements of the Hx/Px pairs are non-halting.
>>>>>>>>
>>>>>>>> Yes, the Px that are completely simulated by their Hx are
>>>>>>>> non-halting, but none of those Hx ever give that answer, so those
>>>>>>>> Hx were wrong.
>>>>>>>
>>>>>>> It is incorrect to say that these Hx are wrong because there is no
>>>>>>> assumption that Hx is a decider.
>>>>>>
>>>>>> The 'H' is 'Hx' stands for "halting" ergo the assumption is that
>>>>>> Hx is
>>>>>> attempting to be a decider.  Don't use 'H' if what you are talking
>>>>>> about isn't a halting decider (this applies to your SHD too which
>>>>>> simply doesn't work as a halting decider).
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> In order to prove that a subset of Hx of the Hx/Px pairs are
>>>>> correct halt deciders I had to show that the every element of the
>>>>> infinite set of correct simulations of Px by Hx never reach the
>>>>> final state of the simulated Px.
>>>>>
>>>>> If no X are Y then anything reporting that no X are Y is correct.
>>>>>
>>>>
>>>> Since the subset that correctly simulate their inputs do NOT get the
>>>> same inputs as the subset that answers,
>>>
>>> One single Hx simultaneously decides for an infinite set of Hx/Px
>>> pairs that is why I switched to sets of Hx. No more switch-a-roo for
>>> you.
>>>
>>>
>>
>> No, because a given Hx only has a single input, the Px built on it.
>>
>
> Does any Px correctly simulated by Hx ever reach the final state of Px?

On 9/10/2022 7:56 PM, Mr Flibble wrote:
> On Sat, 10 Sep 2022 15:55:35 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> 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
>>>
>>>
>>
>> *It* is easy to verify that HH(PP,PP) is correctly designed to do
>> recursive simulation. This was the hardest part of the entire design.
>> https://liarparadox.org/2022_09_07.zip
>>
>> Each emulation requires its own process context including its own
>> stack space.
>
> Recursive simulation is the wrong approach as a halting decider is
> supposed to always return a result to its caller. The Flibble
> Signaling Halt Decider (tm) is a simulating halt decider that does not
> rely on recursion.
>
> /Flibble
>

On 9/11/2022 6:26 AM, Richard Damon wrote:
> On 9/11/22 12:45 AM, olcott wrote:
>> On 9/10/2022 8:31 PM, Richard Damon wrote:
>>> On 9/10/22 9:00 PM, olcott wrote:
>>>> On 9/10/2022 7:23 PM, Richard Damon wrote:
>>>>> On 9/10/22 8:05 PM, olcott wrote:
>>>>>> On 9/10/2022 6:43 PM, Mr Flibble wrote:
>>>>>>> On Sat, 10 Sep 2022 18:27:34 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 9/10/2022 5:55 PM, Richard Damon wrote:
>>>>>>>>> On 9/10/22 6:31 PM, olcott wrote:
>>>>>>>>>> On 9/10/2022 5:24 PM, Richard Damon wrote:
>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, if you simulate for N instructions, and it stops after a
>>>>>>>>>>> higher number M, then it is a HALTING simulstion.
>>>>>>>>>>>
>>>>>>>>>>> You Hx's are ALL wrong (if they give an answer at all) about the
>>>>>>>>>>> behavior of their Px.
>>>>>>>>>>
>>>>>>>>>> Since you already know that no Px correctly and completely
>>>>>>>>>> simulated by Hx reaches its final state you know that these Px
>>>>>>>>>> elements of the Hx/Px pairs are non-halting.
>>>>>>>>>
>>>>>>>>> Yes, the Px that are completely simulated by their Hx are
>>>>>>>>> non-halting, but none of those Hx ever give that answer, so those
>>>>>>>>> Hx were wrong.
>>>>>>>>
>>>>>>>> It is incorrect to say that these Hx are wrong because there is no
>>>>>>>> assumption that Hx is a decider.
>>>>>>>
>>>>>>> The 'H' is 'Hx' stands for "halting" ergo the assumption is that
>>>>>>> Hx is
>>>>>>> attempting to be a decider.  Don't use 'H' if what you are talking
>>>>>>> about isn't a halting decider (this applies to your SHD too which
>>>>>>> simply doesn't work as a halting decider).
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> In order to prove that a subset of Hx of the Hx/Px pairs are
>>>>>> correct halt deciders I had to show that the every element of the
>>>>>> infinite set of correct simulations of Px by Hx never reach the
>>>>>> final state of the simulated Px.
>>>>>>
>>>>>> If no X are Y then anything reporting that no X are Y is correct.
>>>>>>
>>>>>
>>>>> Since the subset that correctly simulate their inputs do NOT get
>>>>> the same inputs as the subset that answers,
>>>>
>>>> One single Hx simultaneously decides for an infinite set of Hx/Px
>>>> pairs that is why I switched to sets of Hx. No more switch-a-roo for
>>>> you.
>>>>
>>>>
>>>
>>> No, because a given Hx only has a single input, the Px built on it.
>>>
>>
>> Does any Px correctly simulated by Hx ever reach the final state of Px?
>
> What does that matter? That's just a Red Herring.

On 9/11/2022 6:26 AM, Richard Damon wrote:
> On 9/11/22 12:45 AM, olcott wrote:
>> On 9/10/2022 8:31 PM, Richard Damon wrote:
>>> On 9/10/22 9:00 PM, olcott wrote:
>>>> On 9/10/2022 7:23 PM, Richard Damon wrote:
>>>>> On 9/10/22 8:05 PM, olcott wrote:
>>>>>> On 9/10/2022 6:43 PM, Mr Flibble wrote:
>>>>>>> On Sat, 10 Sep 2022 18:27:34 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 9/10/2022 5:55 PM, Richard Damon wrote:
>>>>>>>>> On 9/10/22 6:31 PM, olcott wrote:
>>>>>>>>>> On 9/10/2022 5:24 PM, Richard Damon wrote:
>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, if you simulate for N instructions, and it stops after a
>>>>>>>>>>> higher number M, then it is a HALTING simulstion.
>>>>>>>>>>>
>>>>>>>>>>> You Hx's are ALL wrong (if they give an answer at all) about the
>>>>>>>>>>> behavior of their Px.
>>>>>>>>>>
>>>>>>>>>> Since you already know that no Px correctly and completely
>>>>>>>>>> simulated by Hx reaches its final state you know that these Px
>>>>>>>>>> elements of the Hx/Px pairs are non-halting.
>>>>>>>>>
>>>>>>>>> Yes, the Px that are completely simulated by their Hx are
>>>>>>>>> non-halting, but none of those Hx ever give that answer, so those
>>>>>>>>> Hx were wrong.
>>>>>>>>
>>>>>>>> It is incorrect to say that these Hx are wrong because there is no
>>>>>>>> assumption that Hx is a decider.
>>>>>>>
>>>>>>> The 'H' is 'Hx' stands for "halting" ergo the assumption is that
>>>>>>> Hx is
>>>>>>> attempting to be a decider.  Don't use 'H' if what you are talking
>>>>>>> about isn't a halting decider (this applies to your SHD too which
>>>>>>> simply doesn't work as a halting decider).
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> In order to prove that a subset of Hx of the Hx/Px pairs are
>>>>>> correct halt deciders I had to show that the every element of the
>>>>>> infinite set of correct simulations of Px by Hx never reach the
>>>>>> final state of the simulated Px.
>>>>>>
>>>>>> If no X are Y then anything reporting that no X are Y is correct.
>>>>>>
>>>>>
>>>>> Since the subset that correctly simulate their inputs do NOT get
>>>>> the same inputs as the subset that answers,
>>>>
>>>> One single Hx simultaneously decides for an infinite set of Hx/Px
>>>> pairs that is why I switched to sets of Hx. No more switch-a-roo for
>>>> you.
>>>>
>>>>
>>>
>>> No, because a given Hx only has a single input, the Px built on it.
>>>
>>
>> Does any Px correctly simulated by Hx ever reach the final state of Px?
>
> What does that matter? That's just a Red Herring.
>
> That is the definition of POOPING, not Halting.
>
> Halting is about what the machine itself does, or a UTM simulation,
> which, by definition, is the same, not what some non-UTM simulation-like
> thing does with it.
>
> FAIL.
>
>
>>
>>> So, you are just lying.
>>
>> I have never lied, and it may be the case that you also never lied.
>> It does seem (at least) that you have some bias for disagreement.
>
> No, you have firmly stated untruths, which is a definition of a LIE.
>
That is *NOT* the definition of a lie.