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.

On 9/10/2022 5:31 AM, Richard Damon wrote:
> On 9/10/22 12:04 AM, olcott wrote:
>> On 9/9/2022 10:28 PM, Richard Damon wrote:
>>> On 9/9/22 10:52 PM, olcott wrote:
>>>> On 9/9/2022 9:29 PM, Richard Damon wrote:
>>>>> On 9/9/22 10:23 PM, olcott wrote:
>>>>>> On 9/9/2022 9:17 PM, Richard Damon wrote:
>>>>>>> On 9/9/22 7:17 PM, olcott wrote:
>>>>>>>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/9/22 11:02 AM, olcott wrote:
>>>>>>>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>>>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>>>>>> halt therefore any damn thing that says:
>>>>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>> never halt therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And the second statement is nonsense because Px isn't
>>>>>>>>>>>>>>>>> *A* machine, just like Hx isn't A machine.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is why I proved that every element of the infinite
>>>>>>>>>>>>>>>> set of Hx/Px pairs such that Hx correctly and completely
>>>>>>>>>>>>>>>> simulates its input Px never halts. *I named this set
>>>>>>>>>>>>>>>> the HxPx_UTM set*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus any damn thing that claims that the Px elements of
>>>>>>>>>>>>>>>> the HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But you only proved the Px's built on the Hx's that don't
>>>>>>>>>>>>>>> answer were non-halting.
>>>>>>>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be
>>>>>>>>>>>>> able to take in ALL computations.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>
>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>    return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>>    x(y);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Everyone has always said that a halt decider must predict
>>>>>>>>>>>> the behavior of the direct execution of the input thus Hx
>>>>>>>>>>>> must base its halt status decision on the above version of
>>>>>>>>>>>> itself.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, it must decider on its own version of itself. That is the
>>>>>>>>>>> DEFINITION.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If the criteria for a simulating halt decider (SHD) was:
>>>>>>>>>> "Does your correctly simulated input ever stop running ?"
>>>>>>>>>> the SDH would always have to return 1 indicating that its
>>>>>>>>>> input stops running on its own or its input stops running
>>>>>>>>>> because the SHD correctly matched a correct infinite behavior
>>>>>>>>>> pattern and aborted the simulation of its input.
>>>>>>>>>
>>>>>>>>> You keep on using the wrong definitoion, I think because you
>>>>>>>>> just don't know what the words mean.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> This requires the halt status criteria to adopt the Linz
>>>>>>>>>> convention that a sequence of instructions (AKA moves) can
>>>>>>>>>> only be construed as halting when it reaches its own final
>>>>>>>>>> state. This means that every correctly simulated sequence that
>>>>>>>>>> cannot possibly reach its final state specifies a non-halting
>>>>>>>>>> sequence.
>>>>>>>>>
>>>>>>>>> Right, and it is only non-halting when the sequence of steps
>>>>>>>>> specified by that input would NEVER halt if run/simulated for
>>>>>>>>> an unbounded number of step.
>>>>>>>>>
>>>>>>>>> A machine that is artificially stop, doesn't define if it would
>>>>>>>>> have halted or not.
>>>>>>>>>
>>>>>>>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>>>>>>>
>>>>>>>>> A simulation that stop before reaching a final state, by
>>>>>>>>> itself, does not prove anything about the Halting behavior of
>>>>>>>>> that input.
>>>>>>>>
>>>>>>>> We have been through this too many times.
>>>>>>>> There is no sense continuing.
>>>>>>>>
>>>>>>>> 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
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Red Herring.
>>>>>>>
>>>>>>> Just because you can prove for ONE example from a partial a
>>>>>>> partial trace that it will never halt, doesn't mean you can do it
>>>>>>> for all inputs.
>>>>>>>
>>>>>>
>>>>>> You have no interest in truth you only want to argue.
>>>>>>
>>>>>
>>>>> I can say the same about you.
>>>>>
>>>>> You don't care what is ACTUALLY true, only what you want to be true
>>>>> to match your incorrect ideas.
>>>>>
>>>>> I have the ACTAUL DEFINITIONS on my side, you just make up meanings.
>>>>>
>>>>> FAIL.
>>>>
>>>> A simulating halt decider is a new thing and you reject it on that
>>>> basis.
>>>>
>>>
>>> So, are you admitting that a Simulating Hlt Decider isn't a actual
>>> Halt Decider, and thus not constrained by the definition of one?
>> A simulating halt decider is a new idea that you reject entirely on
>> the basis that it is a new idea. Airplanes contradicted the
>> "definition" that humans cannot fly.
>>
>
> So, is it a Halt Decider or not?
>

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.
>

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.

On 9/10/22 10:09 AM, olcott wrote:
> On 9/10/2022 5:31 AM, Richard Damon wrote:
>> On 9/10/22 12:04 AM, olcott wrote:
>>> On 9/9/2022 10:28 PM, Richard Damon wrote:
>>>> On 9/9/22 10:52 PM, olcott wrote:
>>>>> On 9/9/2022 9:29 PM, Richard Damon wrote:
>>>>>> On 9/9/22 10:23 PM, olcott wrote:
>>>>>>> On 9/9/2022 9:17 PM, Richard Damon wrote:
>>>>>>>> On 9/9/22 7:17 PM, olcott wrote:
>>>>>>>>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/9/22 11:02 AM, olcott wrote:
>>>>>>>>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>>>>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>> never halt therefore any damn thing that says:
>>>>>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>> never halt therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And the second statement is nonsense because Px isn't
>>>>>>>>>>>>>>>>>> *A* machine, just like Hx isn't A machine.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is why I proved that every element of the infinite
>>>>>>>>>>>>>>>>> set of Hx/Px pairs such that Hx correctly and
>>>>>>>>>>>>>>>>> completely simulates its input Px never halts. *I named
>>>>>>>>>>>>>>>>> this set the HxPx_UTM set*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus any damn thing that claims that the Px elements of
>>>>>>>>>>>>>>>>> the HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But you only proved the Px's built on the Hx's that
>>>>>>>>>>>>>>>> don't answer were non-halting.
>>>>>>>>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be
>>>>>>>>>>>>>> able to take in ALL computations.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>
>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>    return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Everyone has always said that a halt decider must predict
>>>>>>>>>>>>> the behavior of the direct execution of the input thus Hx
>>>>>>>>>>>>> must base its halt status decision on the above version of
>>>>>>>>>>>>> itself.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, it must decider on its own version of itself. That is
>>>>>>>>>>>> the DEFINITION.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If the criteria for a simulating halt decider (SHD) was:
>>>>>>>>>>> "Does your correctly simulated input ever stop running ?"
>>>>>>>>>>> the SDH would always have to return 1 indicating that its
>>>>>>>>>>> input stops running on its own or its input stops running
>>>>>>>>>>> because the SHD correctly matched a correct infinite behavior
>>>>>>>>>>> pattern and aborted the simulation of its input.
>>>>>>>>>>
>>>>>>>>>> You keep on using the wrong definitoion, I think because you
>>>>>>>>>> just don't know what the words mean.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> This requires the halt status criteria to adopt the Linz
>>>>>>>>>>> convention that a sequence of instructions (AKA moves) can
>>>>>>>>>>> only be construed as halting when it reaches its own final
>>>>>>>>>>> state. This means that every correctly simulated sequence
>>>>>>>>>>> that cannot possibly reach its final state specifies a
>>>>>>>>>>> non-halting sequence.
>>>>>>>>>>
>>>>>>>>>> Right, and it is only non-halting when the sequence of steps
>>>>>>>>>> specified by that input would NEVER halt if run/simulated for
>>>>>>>>>> an unbounded number of step.
>>>>>>>>>>
>>>>>>>>>> A machine that is artificially stop, doesn't define if it
>>>>>>>>>> would have halted or not.
>>>>>>>>>>
>>>>>>>>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>>>>>>>>
>>>>>>>>>> A simulation that stop before reaching a final state, by
>>>>>>>>>> itself, does not prove anything about the Halting behavior of
>>>>>>>>>> that input.
>>>>>>>>>
>>>>>>>>> We have been through this too many times.
>>>>>>>>> There is no sense continuing.
>>>>>>>>>
>>>>>>>>> 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
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Red Herring.
>>>>>>>>
>>>>>>>> Just because you can prove for ONE example from a partial a
>>>>>>>> partial trace that it will never halt, doesn't mean you can do
>>>>>>>> it for all inputs.
>>>>>>>>
>>>>>>>
>>>>>>> You have no interest in truth you only want to argue.
>>>>>>>
>>>>>>
>>>>>> I can say the same about you.
>>>>>>
>>>>>> You don't care what is ACTUALLY true, only what you want to be
>>>>>> true to match your incorrect ideas.
>>>>>>
>>>>>> I have the ACTAUL DEFINITIONS on my side, you just make up meanings.
>>>>>>
>>>>>> FAIL.
>>>>>
>>>>> A simulating halt decider is a new thing and you reject it on that
>>>>> basis.
>>>>>
>>>>
>>>> So, are you admitting that a Simulating Hlt Decider isn't a actual
>>>> Halt Decider, and thus not constrained by the definition of one?
>>> A simulating halt decider is a new idea that you reject entirely on
>>> the basis that it is a new idea. Airplanes contradicted the
>>> "definition" that humans cannot fly.
>>>
>>
>> So, is it a Halt Decider or not?
>>
>
> A halt decider correctly determines whether or not its input specifies a
> sequence of moves that reach their final state.
>
> A simulating halt decider correctly determines whether or not its
> correctly simulated input specifies a sequence of moves that reach their
> final state.

On 9/10/2022 9:28 AM, Richard Damon wrote:
> On 9/10/22 10:09 AM, olcott wrote:
>> On 9/10/2022 5:31 AM, Richard Damon wrote:
>>> On 9/10/22 12:04 AM, olcott wrote:
>>>> On 9/9/2022 10:28 PM, Richard Damon wrote:
>>>>> On 9/9/22 10:52 PM, olcott wrote:
>>>>>> On 9/9/2022 9:29 PM, Richard Damon wrote:
>>>>>>> On 9/9/22 10:23 PM, olcott wrote:
>>>>>>>> On 9/9/2022 9:17 PM, Richard Damon wrote:
>>>>>>>>> On 9/9/22 7:17 PM, olcott wrote:
>>>>>>>>>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/9/22 11:02 AM, olcott wrote:
>>>>>>>>>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>> never halt therefore any damn thing that says:
>>>>>>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>> never halt therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And the second statement is nonsense because Px isn't
>>>>>>>>>>>>>>>>>>> *A* machine, just like Hx isn't A machine.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That is why I proved that every element of the
>>>>>>>>>>>>>>>>>> infinite set of Hx/Px pairs such that Hx correctly and
>>>>>>>>>>>>>>>>>> completely simulates its input Px never halts. *I
>>>>>>>>>>>>>>>>>> named this set the HxPx_UTM set*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus any damn thing that claims that the Px elements
>>>>>>>>>>>>>>>>>> of the HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But you only proved the Px's built on the Hx's that
>>>>>>>>>>>>>>>>> don't answer were non-halting.
>>>>>>>>>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be
>>>>>>>>>>>>>>> able to take in ALL computations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Everyone has always said that a halt decider must predict
>>>>>>>>>>>>>> the behavior of the direct execution of the input thus Hx
>>>>>>>>>>>>>> must base its halt status decision on the above version of
>>>>>>>>>>>>>> itself.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it must decider on its own version of itself. That is
>>>>>>>>>>>>> the DEFINITION.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If the criteria for a simulating halt decider (SHD) was:
>>>>>>>>>>>> "Does your correctly simulated input ever stop running ?"
>>>>>>>>>>>> the SDH would always have to return 1 indicating that its
>>>>>>>>>>>> input stops running on its own or its input stops running
>>>>>>>>>>>> because the SHD correctly matched a correct infinite
>>>>>>>>>>>> behavior pattern and aborted the simulation of its input.
>>>>>>>>>>>
>>>>>>>>>>> You keep on using the wrong definitoion, I think because you
>>>>>>>>>>> just don't know what the words mean.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> This requires the halt status criteria to adopt the Linz
>>>>>>>>>>>> convention that a sequence of instructions (AKA moves) can
>>>>>>>>>>>> only be construed as halting when it reaches its own final
>>>>>>>>>>>> state. This means that every correctly simulated sequence
>>>>>>>>>>>> that cannot possibly reach its final state specifies a
>>>>>>>>>>>> non-halting sequence.
>>>>>>>>>>>
>>>>>>>>>>> Right, and it is only non-halting when the sequence of steps
>>>>>>>>>>> specified by that input would NEVER halt if run/simulated for
>>>>>>>>>>> an unbounded number of step.
>>>>>>>>>>>
>>>>>>>>>>> A machine that is artificially stop, doesn't define if it
>>>>>>>>>>> would have halted or not.
>>>>>>>>>>>
>>>>>>>>>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>>>>>>>>>
>>>>>>>>>>> A simulation that stop before reaching a final state, by
>>>>>>>>>>> itself, does not prove anything about the Halting behavior of
>>>>>>>>>>> that input.
>>>>>>>>>>
>>>>>>>>>> We have been through this too many times.
>>>>>>>>>> There is no sense continuing.
>>>>>>>>>>
>>>>>>>>>> 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
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Red Herring.
>>>>>>>>>
>>>>>>>>> Just because you can prove for ONE example from a partial a
>>>>>>>>> partial trace that it will never halt, doesn't mean you can do
>>>>>>>>> it for all inputs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You have no interest in truth you only want to argue.
>>>>>>>>
>>>>>>>
>>>>>>> I can say the same about you.
>>>>>>>
>>>>>>> You don't care what is ACTUALLY true, only what you want to be
>>>>>>> true to match your incorrect ideas.
>>>>>>>
>>>>>>> I have the ACTAUL DEFINITIONS on my side, you just make up meanings.
>>>>>>>
>>>>>>> FAIL.
>>>>>>
>>>>>> A simulating halt decider is a new thing and you reject it on that
>>>>>> basis.
>>>>>>
>>>>>
>>>>> So, are you admitting that a Simulating Hlt Decider isn't a actual
>>>>> Halt Decider, and thus not constrained by the definition of one?
>>>> A simulating halt decider is a new idea that you reject entirely on
>>>> the basis that it is a new idea. Airplanes contradicted the
>>>> "definition" that humans cannot fly.
>>>>
>>>
>>> So, is it a Halt Decider or not?
>>>
>>
>> A halt decider correctly determines whether or not its input specifies
>> a sequence of moves that reach their final state.
>>
>> A simulating halt decider correctly determines whether or not its
>> correctly simulated input specifies a sequence of moves that reach
>> their final state.
>
> And is "simulation" defined to accurately indicate the behavior of the
> SPECIFEC machine being simulated?

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.
>
>

On 9/10/22 10:31 AM, olcott wrote:
> On 9/10/2022 9:28 AM, Richard Damon wrote:
>> On 9/10/22 10:09 AM, olcott wrote:
>>> On 9/10/2022 5:31 AM, Richard Damon wrote:
>>>> On 9/10/22 12:04 AM, olcott wrote:
>>>>> On 9/9/2022 10:28 PM, Richard Damon wrote:
>>>>>> On 9/9/22 10:52 PM, olcott wrote:
>>>>>>> On 9/9/2022 9:29 PM, Richard Damon wrote:
>>>>>>>> On 9/9/22 10:23 PM, olcott wrote:
>>>>>>>>> On 9/9/2022 9:17 PM, Richard Damon wrote:
>>>>>>>>>> On 9/9/22 7:17 PM, olcott wrote:
>>>>>>>>>>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/9/22 11:02 AM, olcott wrote:
>>>>>>>>>>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>>> never halt therefore any damn thing that says:
>>>>>>>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>>> never halt therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And the second statement is nonsense because Px
>>>>>>>>>>>>>>>>>>>> isn't *A* machine, just like Hx isn't A machine.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Each machine in the Px set can have different
>>>>>>>>>>>>>>>>>>>> behaviors.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is why I proved that every element of the
>>>>>>>>>>>>>>>>>>> infinite set of Hx/Px pairs such that Hx correctly
>>>>>>>>>>>>>>>>>>> and completely simulates its input Px never halts. *I
>>>>>>>>>>>>>>>>>>> named this set the HxPx_UTM set*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus any damn thing that claims that the Px elements
>>>>>>>>>>>>>>>>>>> of the HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But you only proved the Px's built on the Hx's that
>>>>>>>>>>>>>>>>>> don't answer were non-halting.
>>>>>>>>>>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be
>>>>>>>>>>>>>>>> able to take in ALL computations.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Everyone has always said that a halt decider must predict
>>>>>>>>>>>>>>> the behavior of the direct execution of the input thus Hx
>>>>>>>>>>>>>>> must base its halt status decision on the above version
>>>>>>>>>>>>>>> of itself.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, it must decider on its own version of itself. That is
>>>>>>>>>>>>>> the DEFINITION.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the criteria for a simulating halt decider (SHD) was:
>>>>>>>>>>>>> "Does your correctly simulated input ever stop running ?"
>>>>>>>>>>>>> the SDH would always have to return 1 indicating that its
>>>>>>>>>>>>> input stops running on its own or its input stops running
>>>>>>>>>>>>> because the SHD correctly matched a correct infinite
>>>>>>>>>>>>> behavior pattern and aborted the simulation of its input.
>>>>>>>>>>>>
>>>>>>>>>>>> You keep on using the wrong definitoion, I think because you
>>>>>>>>>>>> just don't know what the words mean.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> This requires the halt status criteria to adopt the Linz
>>>>>>>>>>>>> convention that a sequence of instructions (AKA moves) can
>>>>>>>>>>>>> only be construed as halting when it reaches its own final
>>>>>>>>>>>>> state. This means that every correctly simulated sequence
>>>>>>>>>>>>> that cannot possibly reach its final state specifies a
>>>>>>>>>>>>> non-halting sequence.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, and it is only non-halting when the sequence of steps
>>>>>>>>>>>> specified by that input would NEVER halt if run/simulated
>>>>>>>>>>>> for an unbounded number of step.
>>>>>>>>>>>>
>>>>>>>>>>>> A machine that is artificially stop, doesn't define if it
>>>>>>>>>>>> would have halted or not.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>>>>>>>>>>
>>>>>>>>>>>> A simulation that stop before reaching a final state, by
>>>>>>>>>>>> itself, does not prove anything about the Halting behavior
>>>>>>>>>>>> of that input.
>>>>>>>>>>>
>>>>>>>>>>> We have been through this too many times.
>>>>>>>>>>> There is no sense continuing.
>>>>>>>>>>>
>>>>>>>>>>> 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
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Red Herring.
>>>>>>>>>>
>>>>>>>>>> Just because you can prove for ONE example from a partial a
>>>>>>>>>> partial trace that it will never halt, doesn't mean you can do
>>>>>>>>>> it for all inputs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You have no interest in truth you only want to argue.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I can say the same about you.
>>>>>>>>
>>>>>>>> You don't care what is ACTUALLY true, only what you want to be
>>>>>>>> true to match your incorrect ideas.
>>>>>>>>
>>>>>>>> I have the ACTAUL DEFINITIONS on my side, you just make up
>>>>>>>> meanings.
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>
>>>>>>> A simulating halt decider is a new thing and you reject it on
>>>>>>> that basis.
>>>>>>>
>>>>>>
>>>>>> So, are you admitting that a Simulating Hlt Decider isn't a actual
>>>>>> Halt Decider, and thus not constrained by the definition of one?
>>>>> A simulating halt decider is a new idea that you reject entirely on
>>>>> the basis that it is a new idea. Airplanes contradicted the
>>>>> "definition" that humans cannot fly.
>>>>>
>>>>
>>>> So, is it a Halt Decider or not?
>>>>
>>>
>>> A halt decider correctly determines whether or not its input
>>> specifies a sequence of moves that reach their final state.
>>>
>>> A simulating halt decider correctly determines whether or not its
>>> correctly simulated input specifies a sequence of moves that reach
>>> their final state.
>>
>> And is "simulation" defined to accurately indicate the behavior of the
>> SPECIFEC machine being simulated?
>
> 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.
>
>
>

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.
>

On Sat, 10 Sep 2022 09:44:34 -0500
olcott <none-ya@beez-wax.com> wrote:

> On 9/10/2022 9:36 AM, Richard Damon wrote:
> > On 9/10/22 10:16 AM, olcott wrote:
> >> On 9/10/2022 9:12 AM, Richard Damon wrote:
> >>> On 9/10/22 9:58 AM, olcott wrote:
> >>>> On 9/10/2022 6:39 AM, Paul N wrote:
> >>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1, olcott wrote:
> >>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
> >>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1, olcott
> >>>>>>> wrote:
> >>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
> >>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott
> >>>>>>>>> wrote:
> >>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
> >>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott
> >>>>>>>>>>> wrote:
> >>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
> >>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1,
> >>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
> >>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56 PM, olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(Px, Px));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Does any complete and correct simulation of Px by
> >>>>>>>>>>>>>>>>>> Hx ever stop running?
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> We can easily see that if Hx returns zero then Px
> >>>>>>>>>>>>>>>>> halts, and if Hx returns non-zero then Px does not
> >>>>>>>>>>>>>>>>> halt. So Hx can never do a complete and correct
> >>>>>>>>>>>>>>>>> simulation of Px and return the right answer.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *We will call this the UTM subset*
> >>>>>>>>>>>>>>>> We are discussing the infinite set of Hx/Px pairs.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Just to clarify, we're talking about pairs Hx and Px
> >>>>>>>>>>>>>>> where the Px of the pair calls the Hx of the pair as
> >>>>>>>>>>>>>>> in the code above, but we're not putting any
> >>>>>>>>>>>>>>> restrictions on what Hx does?
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> An infinite subset of
> >>>>>>>>>>>>>>>> these do a complete and correct simulation of their
> >>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> If by this you mean that the Hx of the pair correctly
> >>>>>>>>>>>>>>> predicts whether the Px of the pair halts, then no,
> >>>>>>>>>>>>>>> they ALL get it wrong, as shown above.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all of this
> >>>>>>>>>>>>>>>> subset would remain
> >>>>>>>>>>>>>>>> stuck in infinitely recursive simulation such that
> >>>>>>>>>>>>>>>> Px never reaches its
> >>>>>>>>>>>>>>>> final state and the simulation never stops, thus Hx
> >>>>>>>>>>>>>>>> never returns any
> >>>>>>>>>>>>>>>> value.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> This point is moot, there are no pairs in this subset.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *Of the remaining subsets*
> >>>>>>>>>>>>>>>> (1) One of these ignores its input and translates
> >>>>>>>>>>>>>>>> the Lord's prayer into
> >>>>>>>>>>>>>>>> ancient Egyptian.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (2) Another one of these ignores its input and makes
> >>>>>>>>>>>>>>>> all the moves where
> >>>>>>>>>>>>>>>> Deep Blue beat Garry Kasparov in the famous sixth
> >>>>>>>>>>>>>>>> match.
> >>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (3) An infinite subset of the *remaining subsets*
> >>>>>>>>>>>>>>>> ignores its input and
> >>>>>>>>>>>>>>>> returns each element of the set of integers, thus
> >>>>>>>>>>>>>>>> one of them returns 1
> >>>>>>>>>>>>>>>> and another returns 0, this one is called the *wild
> >>>>>>>>>>>>>>>> guess halt decider*
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> All of the wild guess deciders will be wrong. The one
> >>>>>>>>>>>>>>> always guessing 0 will always be wrong for Px, its Px
> >>>>>>>>>>>>>>> will halt. The one always guessing 1 will always be
> >>>>>>>>>>>>>>> wrong for Px, its Px will not halt. Follow the code
> >>>>>>>>>>>>>>> of Px if you don't believe me.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (4) One of these implements the algorithm of my
> >>>>>>>>>>>>>>>> simulating halt decider
> >>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> And this one will be wrong too, see above.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> When it is the job of the halt decider to correctly
> >>>>>>>>>>>>>>>> predict whether or
> >>>>>>>>>>>>>>>> not its correct and complete simulation of its input
> >>>>>>>>>>>>>>>> would halt even the
> >>>>>>>>>>>>>>>> *wild guess halt decider* element of subset (3) is
> >>>>>>>>>>>>>>>> correct:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> return 0;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> No, this is wrong, it predicts Px will not halt, but
> >>>>>>>>>>>>>>> Px does halt. Try running it!
> >>>>>>>>>>>>>> All male humans are humans.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> all correct and complete simulations of Px by Hx never
> >>>>>>>>>>>>>> halt therefore
> >>>>>>>>>>>>>> any damn thing that says:
> >>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx
> >>>>>>>>>>>>>> never halt therefore"
> >>>>>>>>>>>>>> *IS NECESSARILY CORRECT*
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Firstly, I see that you have ignored almost all of what
> >>>>>>>>>>>>> I wrote and are headed off in a different direction. I
> >>>>>>>>>>>>> wonder why?
> >>>>>>>>>>>
> >>>>>>>>>>>> So you don't understand the above point that applies to
> >>>>>>>>>>>> every program
> >>>>>>>>>>>> that return 0?
> >>>>>>>>>>>
> >>>>>>>>>>> If you mean the four lines just above, no, I am not clear
> >>>>>>>>>>> what they say. I'm not even sure you know what they say.
> >>>>>>>>>>> I think you need some words after the second "therefore"
> >>>>>>>>>>> to make them make sense.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> void Px(ptr x)
> >>>>>>>>>> {
> >>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>> if (Halt_Status)
> >>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>> return;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>>>>> }
> >>>>>>>>>> The code for Px is fully specified. The code for Hx is the
> >>>>>>>>>> infinite set
> >>>>>>>>>> of every C function that takes a pair of ptr arguments.
> >>>>>>>>>> These arguments
> >>>>>>>>>> can be ignored, summed together, multiplied together,
> >>>>>>>>>> simulated, or
> >>>>>>>>>> anything else. One element of Hx ignores its arguments,
> >>>>>>>>>> translates the
> >>>>>>>>>> Lord's prayer into ancient Egyptian and returns 56.
> >>>>>>>>>>
> >>>>>>>>>> A subset of these C functions perform a correct partial or
> >>>>>>>>>> complete
> >>>>>>>>>> simulation of their input. In none of the elements of this
> >>>>>>>>>> set does Px
> >>>>>>>>>> ever reach its final state.
> >>>>>>>>>>
> >>>>>>>>>> A subset of the original set return a value of 0, which
> >>>>>>>>>> turns out to be
> >>>>>>>>>> the correct answer to the question:
> >>>>>>>>>>
> >>>>>>>>>> Does there exist any element of the infinite set of Hx/Px
> >>>>>>>>>> pairs such
> >>>>>>>>>> that Px correctly simulated by Hx reaches the final state
> >>>>>>>>>> of Px?
> >>>>>>>>>>
> >>>>>>>>>> One element of the prior set correctly matches a correct
> >>>>>>>>>> infinite behavior pattern, aborts the simulation of its
> >>>>>>>>>> input on the basis and
> >>>>>>>>>> returns 0.
> >>>>>>>>>
> >>>>>>>>> You've quoted the code of Px above, are you really
> >>>>>>>>> incapable of actually understanding it? Let's see:
> >>>>>>>>>
> >>>>>>>>> void Px(ptr x)
> >>>>>>>>> {
> >>>>>>>>> int Halt_Status = Hx(x, x); // you say that Hx(x, x)
> >>>>>>>>> returns 0, so Halt_Status is set to zero
> >>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so this "if"
> >>>>>>>>>> fails... HERE: goto HERE; // ... and so this line is not
> >>>>>>>>>> executed ... return; // ... and we get to here.
> >>>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> So Px halts. There is no infinite behaviour pattern.
> >>>>>>>> I have to update my last reply because I realized that it
> >>>>>>>> was not accurate. I really only want an honest dialogue and
> >>>>>>>> I incorrectly said
> >>>>>>>> that you made a mistake that you did not make.
> >>>>>>>
> >>>>>>> Thank you for this. Yes, I was saying that if Hx(Px, Px)
> >>>>>>> returns 0 then Px halts.
> >>>>>>>
> >>>>>>>> A simulating halt decider (SHD) only reports on the behavior
> >>>>>>>> of what its
> >>>>>>>> complete and correct simulation of its input would be, it
> >>>>>>>> never reports
> >>>>>>>> on the actual behavior of what its partial simulation is.
> >>>>>>>>
> >>>>>>>> If a SHD reported on whether or not its input stopped
> >>>>>>>> running then in
> >>>>>>>> those cases where the simulated input stopped on its own and
> >>>>>>>> those cases
> >>>>>>>> where the simulation was aborted the simulated input stopped
> >>>>>>>> running.
> >>>>>>>> This derives a correct halt decider with no discernment
> >>>>>>>> every input is
> >>>>>>>> reported to stop running.
> >>>>>>>>
> >>>>>>>> To allow a SHD to have discernment it answers a different
> >>>>>>>> question: Does any correct simulation of its input reach the
> >>>>>>>> final state of this
> >>>>>>>> input?
> >>>>>>>
> >>>>>>> The snag is that Hx must always give the wrong answer for Px,
> >>>>>> That is not true. Of the infinite set of Hx that correctly
> >>>>>> simulate Px
> >>>>>> none ever reach the final state of Px.
> >>>>>
> >>>>> I assume when you say "Hx that correctly simulate Px" you're
> >>>>> not just talking about what Hx does internally, you are also
> >>>>> saying that Hx returns the correct answer in a finite time. (If
> >>>>> this is not what you mean then please spell out what you do
> >>>>> mean more clearly.)
> >>>>>
> >>>>> As I've said before, there is not an infinite set of Hx that
> >>>>> correctly simulate Px. EVERY Hx gets its corresponding Px wrong.
> >>>>>
> >>>>>> Every simulating halt decider must only predict the behavior
> >>>>>> of what its
> >>>>>> correct and complete simulation of its input would be and the
> >>>>>> must not
> >>>>>> report on the actual behavior of its partial simulation.
> >>>>>> void Infinite_Loop()
> >>>>>> {
> >>>>>> HERE: goto HERE;
> >>>>>> }
> >>>>>> When H0 reports that its correct and complete simulation of
> >>>>>> its input Infinite_Loop() would never reach the final state of
> >>>>>> this simulated input it has a sound basis.
> >>>>>
> >>>>> Yes, there's no problem with this function and no reason why Hx
> >>>>> need get it wrong. You've said that you have written an Hx
> >>>>> which correctly handles this case and I have no reason to doubt
> >>>>> this.
> >>>>>
> >>>>> The problem with Px is that it necessarily does the opposite of
> >>>>> what Hx predicts it will.
> >>>>
> >>>> You must have not been paying hardly and attention at all.
> >>>>
> >>>> *The correct and complete simulation of the input to Hx(P,P) by
> >>>> Hx* (a) Hx(P,P) simulates P(P) that calls a simulated Hx(P,P)
> >>>> (b) that simulates P(P) that calls a simulated Hx(P,P)
> >>>> (c) that simulates P(P) that calls a simulated Hx(P,P)
> >>>> (d) that simulates P(P) that calls a simulated Hx(P,P)...
> >>>>
> >>>> No correctly simulated Px ever reaches the "if" statement that
> >>>> tests the return value from Hx.
> >>>>
> >>>> *This fully operational code proves that*
> >>>> https://liarparadox.org/2022_09_07.zip
> >>>>
> >>>>
> >>>>> Look at the code for Px - it's very short and simple. Work out
> >>>>> what Px will do if Hx returns 0. Then work out what Px will do
> >>>>> if Hx returns non-zero. Hx is wrong every time, isn't it?
> >>>>>
> >>>>> Another poster gave you an example where he explained the rules
> >>>>> of a game to you but you could not predict what he would do,
> >>>>> because the rules were that he would do the opposite of what
> >>>>> you said. It's exactly the same situation here.
> >>>>>
> >>>>>> When Hx reports that its correct and complete simulation of
> >>>>>> its input Px would never reach the final state of this
> >>>>>> simulated input it has a sound basis.
> >>>>>>
> >>>>>> In neither case does it matter that neither H0 not Hx actually
> >>>>>> performs
> >>>>>> a correct and complete simulation of its input.
> >>>>>>> that is how Px is set up. You can't get round it just by
> >>>>>>> being very very careful about how Hx works.
> >>>>>>>
> >>>>>>>> This question also answers the classic HP question:
> >>>>>>>> Does the direct execution of your input halt?
> >>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>> {
> >>>>>>>> x(y);
> >>>>>>>> }
> >>>>>>>
> >>>>>>> Yes, if x(y) halts then Hx can identify this (I assume you
> >>>>>>> meant to include "return 1;" or the like at the end).
> >>>>
> >>>> The problem is that it never returns a value if x(y) does not
> >>>> halt. Worse still, the user doesn't know whether Hx is running
> >>>> forever (meaning x(y) will not halt) or whether it just hasn't
> >>>> finished yet.
> >>>>
> >>>> Anyone that is competent at these things knows that the above
> >>>> Hx/Px combination remains infinitely recursive forever. When a
> >>>> halt decider Px correctly predicts that it is necessarily
> >>>> correct.
> >>>>
> >>>
> >>> Right *THAT* Hx/Px pair has Px being non-halting, but Hx never
> >>> gives the answer.
> >>
> >> Zero elements of the infinite set of Hx/Px pairs where Hx
> >> correctly simulates its input reach their final state, thus zero
> >> Px elements halt, thus every Hx that returns 0 is correct.
> >>
> >>
> >
> > Bad logic.
> >
>
> When we ask:
> Are male humans human? the answer YES
> Does any Px correctly simulated by Hx halt? the answer NO

On 9/10/2022 10:06 AM, Mr Flibble wrote:
> On Sat, 10 Sep 2022 09:44:34 -0500
> olcott <none-ya@beez-wax.com> wrote:
>
>> On 9/10/2022 9:36 AM, Richard Damon wrote:
>>> On 9/10/22 10:16 AM, olcott wrote:
>>>> On 9/10/2022 9:12 AM, Richard Damon wrote:
>>>>> On 9/10/22 9:58 AM, olcott wrote:
>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1, olcott wrote:
>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1, olcott
>>>>>>>>> wrote:
>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott
>>>>>>>>>>> wrote:
>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1,
>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Does any complete and correct simulation of Px by
>>>>>>>>>>>>>>>>>>>> Hx ever stop running?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns zero then Px
>>>>>>>>>>>>>>>>>>> halts, and if Hx returns non-zero then Px does not
>>>>>>>>>>>>>>>>>>> halt. So Hx can never do a complete and correct
>>>>>>>>>>>>>>>>>>> simulation of Px and return the right answer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
>>>>>>>>>>>>>>>>>> We are discussing the infinite set of Hx/Px pairs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Just to clarify, we're talking about pairs Hx and Px
>>>>>>>>>>>>>>>>> where the Px of the pair calls the Hx of the pair as
>>>>>>>>>>>>>>>>> in the code above, but we're not putting any
>>>>>>>>>>>>>>>>> restrictions on what Hx does?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> An infinite subset of
>>>>>>>>>>>>>>>>>> these do a complete and correct simulation of their
>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the pair correctly
>>>>>>>>>>>>>>>>> predicts whether the Px of the pair halts, then no,
>>>>>>>>>>>>>>>>> they ALL get it wrong, as shown above.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all of this
>>>>>>>>>>>>>>>>>> subset would remain
>>>>>>>>>>>>>>>>>> stuck in infinitely recursive simulation such that
>>>>>>>>>>>>>>>>>> Px never reaches its
>>>>>>>>>>>>>>>>>> final state and the simulation never stops, thus Hx
>>>>>>>>>>>>>>>>>> never returns any
>>>>>>>>>>>>>>>>>> value.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This point is moot, there are no pairs in this subset.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and translates
>>>>>>>>>>>>>>>>>> the Lord's prayer into
>>>>>>>>>>>>>>>>>> ancient Egyptian.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its input and makes
>>>>>>>>>>>>>>>>>> all the moves where
>>>>>>>>>>>>>>>>>> Deep Blue beat Garry Kasparov in the famous sixth
>>>>>>>>>>>>>>>>>> match.
>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (3) An infinite subset of the *remaining subsets*
>>>>>>>>>>>>>>>>>> ignores its input and
>>>>>>>>>>>>>>>>>> returns each element of the set of integers, thus
>>>>>>>>>>>>>>>>>> one of them returns 1
>>>>>>>>>>>>>>>>>> and another returns 0, this one is called the *wild
>>>>>>>>>>>>>>>>>> guess halt decider*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All of the wild guess deciders will be wrong. The one
>>>>>>>>>>>>>>>>> always guessing 0 will always be wrong for Px, its Px
>>>>>>>>>>>>>>>>> will halt. The one always guessing 1 will always be
>>>>>>>>>>>>>>>>> wrong for Px, its Px will not halt. Follow the code
>>>>>>>>>>>>>>>>> of Px if you don't believe me.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (4) One of these implements the algorithm of my
>>>>>>>>>>>>>>>>>> simulating halt decider
>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When it is the job of the halt decider to correctly
>>>>>>>>>>>>>>>>>> predict whether or
>>>>>>>>>>>>>>>>>> not its correct and complete simulation of its input
>>>>>>>>>>>>>>>>>> would halt even the
>>>>>>>>>>>>>>>>>> *wild guess halt decider* element of subset (3) is
>>>>>>>>>>>>>>>>>> correct:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> return 0;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will not halt, but
>>>>>>>>>>>>>>>>> Px does halt. Try running it!
>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>>>> halt therefore
>>>>>>>>>>>>>>>> any damn thing that says:
>>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>> never halt therefore"
>>>>>>>>>>>>>>>> *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Firstly, I see that you have ignored almost all of what
>>>>>>>>>>>>>>> I wrote and are headed off in a different direction. I
>>>>>>>>>>>>>>> wonder why?
>>>>>>>>>>>>>
>>>>>>>>>>>>>> So you don't understand the above point that applies to
>>>>>>>>>>>>>> every program
>>>>>>>>>>>>>> that return 0?
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you mean the four lines just above, no, I am not clear
>>>>>>>>>>>>> what they say. I'm not even sure you know what they say.
>>>>>>>>>>>>> I think you need some words after the second "therefore"
>>>>>>>>>>>>> to make them make sense.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>> }
>>>>>>>>>>>> The code for Px is fully specified. The code for Hx is the
>>>>>>>>>>>> infinite set
>>>>>>>>>>>> of every C function that takes a pair of ptr arguments.
>>>>>>>>>>>> These arguments
>>>>>>>>>>>> can be ignored, summed together, multiplied together,
>>>>>>>>>>>> simulated, or
>>>>>>>>>>>> anything else. One element of Hx ignores its arguments,
>>>>>>>>>>>> translates the
>>>>>>>>>>>> Lord's prayer into ancient Egyptian and returns 56.
>>>>>>>>>>>>
>>>>>>>>>>>> A subset of these C functions perform a correct partial or
>>>>>>>>>>>> complete
>>>>>>>>>>>> simulation of their input. In none of the elements of this
>>>>>>>>>>>> set does Px
>>>>>>>>>>>> ever reach its final state.
>>>>>>>>>>>>
>>>>>>>>>>>> A subset of the original set return a value of 0, which
>>>>>>>>>>>> turns out to be
>>>>>>>>>>>> the correct answer to the question:
>>>>>>>>>>>>
>>>>>>>>>>>> Does there exist any element of the infinite set of Hx/Px
>>>>>>>>>>>> pairs such
>>>>>>>>>>>> that Px correctly simulated by Hx reaches the final state
>>>>>>>>>>>> of Px?
>>>>>>>>>>>>
>>>>>>>>>>>> One element of the prior set correctly matches a correct
>>>>>>>>>>>> infinite behavior pattern, aborts the simulation of its
>>>>>>>>>>>> input on the basis and
>>>>>>>>>>>> returns 0.
>>>>>>>>>>>
>>>>>>>>>>> You've quoted the code of Px above, are you really
>>>>>>>>>>> incapable of actually understanding it? Let's see:
>>>>>>>>>>>
>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that Hx(x, x)
>>>>>>>>>>> returns 0, so Halt_Status is set to zero
>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so this "if"
>>>>>>>>>>>> fails... HERE: goto HERE; // ... and so this line is not
>>>>>>>>>>>> executed ... return; // ... and we get to here.
>>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> So Px halts. There is no infinite behaviour pattern.
>>>>>>>>>> I have to update my last reply because I realized that it
>>>>>>>>>> was not accurate. I really only want an honest dialogue and
>>>>>>>>>> I incorrectly said
>>>>>>>>>> that you made a mistake that you did not make.
>>>>>>>>>
>>>>>>>>> Thank you for this. Yes, I was saying that if Hx(Px, Px)
>>>>>>>>> returns 0 then Px halts.
>>>>>>>>>
>>>>>>>>>> A simulating halt decider (SHD) only reports on the behavior
>>>>>>>>>> of what its
>>>>>>>>>> complete and correct simulation of its input would be, it
>>>>>>>>>> never reports
>>>>>>>>>> on the actual behavior of what its partial simulation is.
>>>>>>>>>>
>>>>>>>>>> If a SHD reported on whether or not its input stopped
>>>>>>>>>> running then in
>>>>>>>>>> those cases where the simulated input stopped on its own and
>>>>>>>>>> those cases
>>>>>>>>>> where the simulation was aborted the simulated input stopped
>>>>>>>>>> running.
>>>>>>>>>> This derives a correct halt decider with no discernment
>>>>>>>>>> every input is
>>>>>>>>>> reported to stop running.
>>>>>>>>>>
>>>>>>>>>> To allow a SHD to have discernment it answers a different
>>>>>>>>>> question: Does any correct simulation of its input reach the
>>>>>>>>>> final state of this
>>>>>>>>>> input?
>>>>>>>>>
>>>>>>>>> The snag is that Hx must always give the wrong answer for Px,
>>>>>>>> That is not true. Of the infinite set of Hx that correctly
>>>>>>>> simulate Px
>>>>>>>> none ever reach the final state of Px.
>>>>>>>
>>>>>>> I assume when you say "Hx that correctly simulate Px" you're
>>>>>>> not just talking about what Hx does internally, you are also
>>>>>>> saying that Hx returns the correct answer in a finite time. (If
>>>>>>> this is not what you mean then please spell out what you do
>>>>>>> mean more clearly.)
>>>>>>>
>>>>>>> As I've said before, there is not an infinite set of Hx that
>>>>>>> correctly simulate Px. EVERY Hx gets its corresponding Px wrong.
>>>>>>>
>>>>>>>> Every simulating halt decider must only predict the behavior
>>>>>>>> of what its
>>>>>>>> correct and complete simulation of its input would be and the
>>>>>>>> must not
>>>>>>>> report on the actual behavior of its partial simulation.
>>>>>>>> void Infinite_Loop()
>>>>>>>> {
>>>>>>>> HERE: goto HERE;
>>>>>>>> }
>>>>>>>> When H0 reports that its correct and complete simulation of
>>>>>>>> its input Infinite_Loop() would never reach the final state of
>>>>>>>> this simulated input it has a sound basis.
>>>>>>>
>>>>>>> Yes, there's no problem with this function and no reason why Hx
>>>>>>> need get it wrong. You've said that you have written an Hx
>>>>>>> which correctly handles this case and I have no reason to doubt
>>>>>>> this.
>>>>>>>
>>>>>>> The problem with Px is that it necessarily does the opposite of
>>>>>>> what Hx predicts it will.
>>>>>>
>>>>>> You must have not been paying hardly and attention at all.
>>>>>>
>>>>>> *The correct and complete simulation of the input to Hx(P,P) by
>>>>>> Hx* (a) Hx(P,P) simulates P(P) that calls a simulated Hx(P,P)
>>>>>> (b) that simulates P(P) that calls a simulated Hx(P,P)
>>>>>> (c) that simulates P(P) that calls a simulated Hx(P,P)
>>>>>> (d) that simulates P(P) that calls a simulated Hx(P,P)...
>>>>>>
>>>>>> No correctly simulated Px ever reaches the "if" statement that
>>>>>> tests the return value from Hx.
>>>>>>
>>>>>> *This fully operational code proves that*
>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>
>>>>>>
>>>>>>> Look at the code for Px - it's very short and simple. Work out
>>>>>>> what Px will do if Hx returns 0. Then work out what Px will do
>>>>>>> if Hx returns non-zero. Hx is wrong every time, isn't it?
>>>>>>>
>>>>>>> Another poster gave you an example where he explained the rules
>>>>>>> of a game to you but you could not predict what he would do,
>>>>>>> because the rules were that he would do the opposite of what
>>>>>>> you said. It's exactly the same situation here.
>>>>>>>
>>>>>>>> When Hx reports that its correct and complete simulation of
>>>>>>>> its input Px would never reach the final state of this
>>>>>>>> simulated input it has a sound basis.
>>>>>>>>
>>>>>>>> In neither case does it matter that neither H0 not Hx actually
>>>>>>>> performs
>>>>>>>> a correct and complete simulation of its input.
>>>>>>>>> that is how Px is set up. You can't get round it just by
>>>>>>>>> being very very careful about how Hx works.
>>>>>>>>>
>>>>>>>>>> This question also answers the classic HP question:
>>>>>>>>>> Does the direct execution of your input halt?
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>> x(y);
>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Yes, if x(y) halts then Hx can identify this (I assume you
>>>>>>>>> meant to include "return 1;" or the like at the end).
>>>>>>
>>>>>> The problem is that it never returns a value if x(y) does not
>>>>>> halt. Worse still, the user doesn't know whether Hx is running
>>>>>> forever (meaning x(y) will not halt) or whether it just hasn't
>>>>>> finished yet.
>>>>>>
>>>>>> Anyone that is competent at these things knows that the above
>>>>>> Hx/Px combination remains infinitely recursive forever. When a
>>>>>> halt decider Px correctly predicts that it is necessarily
>>>>>> correct.
>>>>>>
>>>>>
>>>>> Right *THAT* Hx/Px pair has Px being non-halting, but Hx never
>>>>> gives the answer.
>>>>
>>>> Zero elements of the infinite set of Hx/Px pairs where Hx
>>>> correctly simulates its input reach their final state, thus zero
>>>> Px elements halt, thus every Hx that returns 0 is correct.
>>>>
>>>>
>>>
>>> Bad logic.
>>>
>>
>> When we ask:
>> Are male humans human? the answer YES
>> Does any Px correctly simulated by Hx halt? the answer NO
>
> The answer is YES:
>
> void Px(void (*x)())
> {
> (void) Hx(x, x);
> return;
> }
>

On Sat, 10 Sep 2022 10:13:33 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/10/2022 10:06 AM, Mr Flibble wrote:
> > On Sat, 10 Sep 2022 09:44:34 -0500
> > olcott <none-ya@beez-wax.com> wrote:
> >
> >> On 9/10/2022 9:36 AM, Richard Damon wrote:
> >>> On 9/10/22 10:16 AM, olcott wrote:
> >>>> On 9/10/2022 9:12 AM, Richard Damon wrote:
> >>>>> On 9/10/22 9:58 AM, olcott wrote:
> >>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
> >>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1, olcott
> >>>>>>> wrote:
> >>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
> >>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1, olcott
> >>>>>>>>> wrote:
> >>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
> >>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott
> >>>>>>>>>>> wrote:
> >>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
> >>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott
> >>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
> >>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM
> >>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56 PM, olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(Px, Px));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Does any complete and correct simulation of Px by
> >>>>>>>>>>>>>>>>>>>> Hx ever stop running?
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns zero then Px
> >>>>>>>>>>>>>>>>>>> halts, and if Hx returns non-zero then Px does not
> >>>>>>>>>>>>>>>>>>> halt. So Hx can never do a complete and correct
> >>>>>>>>>>>>>>>>>>> simulation of Px and return the right answer.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
> >>>>>>>>>>>>>>>>>> We are discussing the infinite set of Hx/Px pairs.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Just to clarify, we're talking about pairs Hx and Px
> >>>>>>>>>>>>>>>>> where the Px of the pair calls the Hx of the pair as
> >>>>>>>>>>>>>>>>> in the code above, but we're not putting any
> >>>>>>>>>>>>>>>>> restrictions on what Hx does?
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> An infinite subset of
> >>>>>>>>>>>>>>>>>> these do a complete and correct simulation of their
> >>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> If by this you mean that the Hx of the pair
> >>>>>>>>>>>>>>>>> correctly predicts whether the Px of the pair
> >>>>>>>>>>>>>>>>> halts, then no, they ALL get it wrong, as shown
> >>>>>>>>>>>>>>>>> above.
> >>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all of this
> >>>>>>>>>>>>>>>>>> subset would remain
> >>>>>>>>>>>>>>>>>> stuck in infinitely recursive simulation such that
> >>>>>>>>>>>>>>>>>> Px never reaches its
> >>>>>>>>>>>>>>>>>> final state and the simulation never stops, thus Hx
> >>>>>>>>>>>>>>>>>> never returns any
> >>>>>>>>>>>>>>>>>> value.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> This point is moot, there are no pairs in this
> >>>>>>>>>>>>>>>>> subset.
> >>>>>>>>>>>>>>>>>> *Of the remaining subsets*
> >>>>>>>>>>>>>>>>>> (1) One of these ignores its input and translates
> >>>>>>>>>>>>>>>>>> the Lord's prayer into
> >>>>>>>>>>>>>>>>>> ancient Egyptian.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> (2) Another one of these ignores its input and
> >>>>>>>>>>>>>>>>>> makes all the moves where
> >>>>>>>>>>>>>>>>>> Deep Blue beat Garry Kasparov in the famous sixth
> >>>>>>>>>>>>>>>>>> match.
> >>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> (3) An infinite subset of the *remaining subsets*
> >>>>>>>>>>>>>>>>>> ignores its input and
> >>>>>>>>>>>>>>>>>> returns each element of the set of integers, thus
> >>>>>>>>>>>>>>>>>> one of them returns 1
> >>>>>>>>>>>>>>>>>> and another returns 0, this one is called the *wild
> >>>>>>>>>>>>>>>>>> guess halt decider*
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> All of the wild guess deciders will be wrong. The
> >>>>>>>>>>>>>>>>> one always guessing 0 will always be wrong for Px,
> >>>>>>>>>>>>>>>>> its Px will halt. The one always guessing 1 will
> >>>>>>>>>>>>>>>>> always be wrong for Px, its Px will not halt.
> >>>>>>>>>>>>>>>>> Follow the code of Px if you don't believe me.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> (4) One of these implements the algorithm of my
> >>>>>>>>>>>>>>>>>> simulating halt decider
> >>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> When it is the job of the halt decider to correctly
> >>>>>>>>>>>>>>>>>> predict whether or
> >>>>>>>>>>>>>>>>>> not its correct and complete simulation of its
> >>>>>>>>>>>>>>>>>> input would halt even the
> >>>>>>>>>>>>>>>>>> *wild guess halt decider* element of subset (3) is
> >>>>>>>>>>>>>>>>>> correct:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> return 0;
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will not halt, but
> >>>>>>>>>>>>>>>>> Px does halt. Try running it!
> >>>>>>>>>>>>>>>> All male humans are humans.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx
> >>>>>>>>>>>>>>>> never halt therefore
> >>>>>>>>>>>>>>>> any damn thing that says:
> >>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx
> >>>>>>>>>>>>>>>> never halt therefore"
> >>>>>>>>>>>>>>>> *IS NECESSARILY CORRECT*
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Firstly, I see that you have ignored almost all of
> >>>>>>>>>>>>>>> what I wrote and are headed off in a different
> >>>>>>>>>>>>>>> direction. I wonder why?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> So you don't understand the above point that applies to
> >>>>>>>>>>>>>> every program
> >>>>>>>>>>>>>> that return 0?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If you mean the four lines just above, no, I am not
> >>>>>>>>>>>>> clear what they say. I'm not even sure you know what
> >>>>>>>>>>>>> they say. I think you need some words after the second
> >>>>>>>>>>>>> "therefore" to make them make sense.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>> return;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>>>>>>> }
> >>>>>>>>>>>> The code for Px is fully specified. The code for Hx is
> >>>>>>>>>>>> the infinite set
> >>>>>>>>>>>> of every C function that takes a pair of ptr arguments.
> >>>>>>>>>>>> These arguments
> >>>>>>>>>>>> can be ignored, summed together, multiplied together,
> >>>>>>>>>>>> simulated, or
> >>>>>>>>>>>> anything else. One element of Hx ignores its arguments,
> >>>>>>>>>>>> translates the
> >>>>>>>>>>>> Lord's prayer into ancient Egyptian and returns 56.
> >>>>>>>>>>>>
> >>>>>>>>>>>> A subset of these C functions perform a correct partial
> >>>>>>>>>>>> or complete
> >>>>>>>>>>>> simulation of their input. In none of the elements of
> >>>>>>>>>>>> this set does Px
> >>>>>>>>>>>> ever reach its final state.
> >>>>>>>>>>>>
> >>>>>>>>>>>> A subset of the original set return a value of 0, which
> >>>>>>>>>>>> turns out to be
> >>>>>>>>>>>> the correct answer to the question:
> >>>>>>>>>>>>
> >>>>>>>>>>>> Does there exist any element of the infinite set of Hx/Px
> >>>>>>>>>>>> pairs such
> >>>>>>>>>>>> that Px correctly simulated by Hx reaches the final state
> >>>>>>>>>>>> of Px?
> >>>>>>>>>>>>
> >>>>>>>>>>>> One element of the prior set correctly matches a correct
> >>>>>>>>>>>> infinite behavior pattern, aborts the simulation of its
> >>>>>>>>>>>> input on the basis and
> >>>>>>>>>>>> returns 0.
> >>>>>>>>>>>
> >>>>>>>>>>> You've quoted the code of Px above, are you really
> >>>>>>>>>>> incapable of actually understanding it? Let's see:
> >>>>>>>>>>>
> >>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>> {
> >>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that Hx(x, x)
> >>>>>>>>>>> returns 0, so Halt_Status is set to zero
> >>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so this "if"
> >>>>>>>>>>>> fails... HERE: goto HERE; // ... and so this line is not
> >>>>>>>>>>>> executed ... return; // ... and we get to here.
> >>>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> So Px halts. There is no infinite behaviour pattern.
> >>>>>>>>>> I have to update my last reply because I realized that it
> >>>>>>>>>> was not accurate. I really only want an honest dialogue and
> >>>>>>>>>> I incorrectly said
> >>>>>>>>>> that you made a mistake that you did not make.
> >>>>>>>>>
> >>>>>>>>> Thank you for this. Yes, I was saying that if Hx(Px, Px)
> >>>>>>>>> returns 0 then Px halts.
> >>>>>>>>>
> >>>>>>>>>> A simulating halt decider (SHD) only reports on the
> >>>>>>>>>> behavior of what its
> >>>>>>>>>> complete and correct simulation of its input would be, it
> >>>>>>>>>> never reports
> >>>>>>>>>> on the actual behavior of what its partial simulation is.
> >>>>>>>>>>
> >>>>>>>>>> If a SHD reported on whether or not its input stopped
> >>>>>>>>>> running then in
> >>>>>>>>>> those cases where the simulated input stopped on its own
> >>>>>>>>>> and those cases
> >>>>>>>>>> where the simulation was aborted the simulated input
> >>>>>>>>>> stopped running.
> >>>>>>>>>> This derives a correct halt decider with no discernment
> >>>>>>>>>> every input is
> >>>>>>>>>> reported to stop running.
> >>>>>>>>>>
> >>>>>>>>>> To allow a SHD to have discernment it answers a different
> >>>>>>>>>> question: Does any correct simulation of its input reach
> >>>>>>>>>> the final state of this
> >>>>>>>>>> input?
> >>>>>>>>>
> >>>>>>>>> The snag is that Hx must always give the wrong answer for
> >>>>>>>>> Px,
> >>>>>>>> That is not true. Of the infinite set of Hx that correctly
> >>>>>>>> simulate Px
> >>>>>>>> none ever reach the final state of Px.
> >>>>>>>
> >>>>>>> I assume when you say "Hx that correctly simulate Px" you're
> >>>>>>> not just talking about what Hx does internally, you are also
> >>>>>>> saying that Hx returns the correct answer in a finite time.
> >>>>>>> (If this is not what you mean then please spell out what you
> >>>>>>> do mean more clearly.)
> >>>>>>>
> >>>>>>> As I've said before, there is not an infinite set of Hx that
> >>>>>>> correctly simulate Px. EVERY Hx gets its corresponding Px
> >>>>>>> wrong.
> >>>>>>>> Every simulating halt decider must only predict the behavior
> >>>>>>>> of what its
> >>>>>>>> correct and complete simulation of its input would be and the
> >>>>>>>> must not
> >>>>>>>> report on the actual behavior of its partial simulation.
> >>>>>>>> void Infinite_Loop()
> >>>>>>>> {
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> }
> >>>>>>>> When H0 reports that its correct and complete simulation of
> >>>>>>>> its input Infinite_Loop() would never reach the final state
> >>>>>>>> of this simulated input it has a sound basis.
> >>>>>>>
> >>>>>>> Yes, there's no problem with this function and no reason why
> >>>>>>> Hx need get it wrong. You've said that you have written an Hx
> >>>>>>> which correctly handles this case and I have no reason to
> >>>>>>> doubt this.
> >>>>>>>
> >>>>>>> The problem with Px is that it necessarily does the opposite
> >>>>>>> of what Hx predicts it will.
> >>>>>>
> >>>>>> You must have not been paying hardly and attention at all.
> >>>>>>
> >>>>>> *The correct and complete simulation of the input to Hx(P,P) by
> >>>>>> Hx* (a) Hx(P,P) simulates P(P) that calls a simulated Hx(P,P)
> >>>>>> (b) that simulates P(P) that calls a simulated Hx(P,P)
> >>>>>> (c) that simulates P(P) that calls a simulated Hx(P,P)
> >>>>>> (d) that simulates P(P) that calls a simulated Hx(P,P)...
> >>>>>>
> >>>>>> No correctly simulated Px ever reaches the "if" statement that
> >>>>>> tests the return value from Hx.
> >>>>>>
> >>>>>> *This fully operational code proves that*
> >>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>>
> >>>>>>
> >>>>>>> Look at the code for Px - it's very short and simple. Work out
> >>>>>>> what Px will do if Hx returns 0. Then work out what Px will do
> >>>>>>> if Hx returns non-zero. Hx is wrong every time, isn't it?
> >>>>>>>
> >>>>>>> Another poster gave you an example where he explained the
> >>>>>>> rules of a game to you but you could not predict what he
> >>>>>>> would do, because the rules were that he would do the
> >>>>>>> opposite of what you said. It's exactly the same situation
> >>>>>>> here.
> >>>>>>>> When Hx reports that its correct and complete simulation of
> >>>>>>>> its input Px would never reach the final state of this
> >>>>>>>> simulated input it has a sound basis.
> >>>>>>>>
> >>>>>>>> In neither case does it matter that neither H0 not Hx
> >>>>>>>> actually performs
> >>>>>>>> a correct and complete simulation of its input.
> >>>>>>>>> that is how Px is set up. You can't get round it just by
> >>>>>>>>> being very very careful about how Hx works.
> >>>>>>>>>
> >>>>>>>>>> This question also answers the classic HP question:
> >>>>>>>>>> Does the direct execution of your input halt?
> >>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>> {
> >>>>>>>>>> x(y);
> >>>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> Yes, if x(y) halts then Hx can identify this (I assume you
> >>>>>>>>> meant to include "return 1;" or the like at the end).
> >>>>>>
> >>>>>> The problem is that it never returns a value if x(y) does not
> >>>>>> halt. Worse still, the user doesn't know whether Hx is running
> >>>>>> forever (meaning x(y) will not halt) or whether it just hasn't
> >>>>>> finished yet.
> >>>>>>
> >>>>>> Anyone that is competent at these things knows that the above
> >>>>>> Hx/Px combination remains infinitely recursive forever. When a
> >>>>>> halt decider Px correctly predicts that it is necessarily
> >>>>>> correct.
> >>>>>>
> >>>>>
> >>>>> Right *THAT* Hx/Px pair has Px being non-halting, but Hx never
> >>>>> gives the answer.
> >>>>
> >>>> Zero elements of the infinite set of Hx/Px pairs where Hx
> >>>> correctly simulates its input reach their final state, thus zero
> >>>> Px elements halt, thus every Hx that returns 0 is correct.
> >>>>
> >>>>
> >>>
> >>> Bad logic.
> >>>
> >>
> >> When we ask:
> >> Are male humans human? the answer YES
> >> Does any Px correctly simulated by Hx halt? the answer NO
> >
> > The answer is YES:
> >
> > void Px(void (*x)())
> > {
> > (void) Hx(x, x);
> > return;
> > }
> >
>
> That is not an example of a Px that when correctly simulated by Hx
> halts, incorrect simulations do not count.

On 9/10/2022 10:33 AM, Mr Flibble wrote:
> On Sat, 10 Sep 2022 10:13:33 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 9/10/2022 10:06 AM, Mr Flibble wrote:
>>> On Sat, 10 Sep 2022 09:44:34 -0500
>>> olcott <none-ya@beez-wax.com> wrote:
>>>
>>>> On 9/10/2022 9:36 AM, Richard Damon wrote:
>>>>> On 9/10/22 10:16 AM, olcott wrote:
>>>>>> On 9/10/2022 9:12 AM, Richard Damon wrote:
>>>>>>> On 9/10/22 9:58 AM, olcott wrote:
>>>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
>>>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1, olcott
>>>>>>>>> wrote:
>>>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
>>>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1, olcott
>>>>>>>>>>> wrote:
>>>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
>>>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM
>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Does any complete and correct simulation of Px by
>>>>>>>>>>>>>>>>>>>>>> Hx ever stop running?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns zero then Px
>>>>>>>>>>>>>>>>>>>>> halts, and if Hx returns non-zero then Px does not
>>>>>>>>>>>>>>>>>>>>> halt. So Hx can never do a complete and correct
>>>>>>>>>>>>>>>>>>>>> simulation of Px and return the right answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
>>>>>>>>>>>>>>>>>>>> We are discussing the infinite set of Hx/Px pairs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Just to clarify, we're talking about pairs Hx and Px
>>>>>>>>>>>>>>>>>>> where the Px of the pair calls the Hx of the pair as
>>>>>>>>>>>>>>>>>>> in the code above, but we're not putting any
>>>>>>>>>>>>>>>>>>> restrictions on what Hx does?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> An infinite subset of
>>>>>>>>>>>>>>>>>>>> these do a complete and correct simulation of their
>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the pair
>>>>>>>>>>>>>>>>>>> correctly predicts whether the Px of the pair
>>>>>>>>>>>>>>>>>>> halts, then no, they ALL get it wrong, as shown
>>>>>>>>>>>>>>>>>>> above.
>>>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all of this
>>>>>>>>>>>>>>>>>>>> subset would remain
>>>>>>>>>>>>>>>>>>>> stuck in infinitely recursive simulation such that
>>>>>>>>>>>>>>>>>>>> Px never reaches its
>>>>>>>>>>>>>>>>>>>> final state and the simulation never stops, thus Hx
>>>>>>>>>>>>>>>>>>>> never returns any
>>>>>>>>>>>>>>>>>>>> value.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This point is moot, there are no pairs in this
>>>>>>>>>>>>>>>>>>> subset.
>>>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
>>>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and translates
>>>>>>>>>>>>>>>>>>>> the Lord's prayer into
>>>>>>>>>>>>>>>>>>>> ancient Egyptian.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its input and
>>>>>>>>>>>>>>>>>>>> makes all the moves where
>>>>>>>>>>>>>>>>>>>> Deep Blue beat Garry Kasparov in the famous sixth
>>>>>>>>>>>>>>>>>>>> match.
>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (3) An infinite subset of the *remaining subsets*
>>>>>>>>>>>>>>>>>>>> ignores its input and
>>>>>>>>>>>>>>>>>>>> returns each element of the set of integers, thus
>>>>>>>>>>>>>>>>>>>> one of them returns 1
>>>>>>>>>>>>>>>>>>>> and another returns 0, this one is called the *wild
>>>>>>>>>>>>>>>>>>>> guess halt decider*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> All of the wild guess deciders will be wrong. The
>>>>>>>>>>>>>>>>>>> one always guessing 0 will always be wrong for Px,
>>>>>>>>>>>>>>>>>>> its Px will halt. The one always guessing 1 will
>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will not halt.
>>>>>>>>>>>>>>>>>>> Follow the code of Px if you don't believe me.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (4) One of these implements the algorithm of my
>>>>>>>>>>>>>>>>>>>> simulating halt decider
>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When it is the job of the halt decider to correctly
>>>>>>>>>>>>>>>>>>>> predict whether or
>>>>>>>>>>>>>>>>>>>> not its correct and complete simulation of its
>>>>>>>>>>>>>>>>>>>> input would halt even the
>>>>>>>>>>>>>>>>>>>> *wild guess halt decider* element of subset (3) is
>>>>>>>>>>>>>>>>>>>> correct:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> return 0;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will not halt, but
>>>>>>>>>>>>>>>>>>> Px does halt. Try running it!
>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>> never halt therefore
>>>>>>>>>>>>>>>>>> any damn thing that says:
>>>>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>> never halt therefore"
>>>>>>>>>>>>>>>>>> *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Firstly, I see that you have ignored almost all of
>>>>>>>>>>>>>>>>> what I wrote and are headed off in a different
>>>>>>>>>>>>>>>>> direction. I wonder why?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So you don't understand the above point that applies to
>>>>>>>>>>>>>>>> every program
>>>>>>>>>>>>>>>> that return 0?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you mean the four lines just above, no, I am not
>>>>>>>>>>>>>>> clear what they say. I'm not even sure you know what
>>>>>>>>>>>>>>> they say. I think you need some words after the second
>>>>>>>>>>>>>>> "therefore" to make them make sense.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>> The code for Px is fully specified. The code for Hx is
>>>>>>>>>>>>>> the infinite set
>>>>>>>>>>>>>> of every C function that takes a pair of ptr arguments.
>>>>>>>>>>>>>> These arguments
>>>>>>>>>>>>>> can be ignored, summed together, multiplied together,
>>>>>>>>>>>>>> simulated, or
>>>>>>>>>>>>>> anything else. One element of Hx ignores its arguments,
>>>>>>>>>>>>>> translates the
>>>>>>>>>>>>>> Lord's prayer into ancient Egyptian and returns 56.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A subset of these C functions perform a correct partial
>>>>>>>>>>>>>> or complete
>>>>>>>>>>>>>> simulation of their input. In none of the elements of
>>>>>>>>>>>>>> this set does Px
>>>>>>>>>>>>>> ever reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A subset of the original set return a value of 0, which
>>>>>>>>>>>>>> turns out to be
>>>>>>>>>>>>>> the correct answer to the question:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Does there exist any element of the infinite set of Hx/Px
>>>>>>>>>>>>>> pairs such
>>>>>>>>>>>>>> that Px correctly simulated by Hx reaches the final state
>>>>>>>>>>>>>> of Px?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> One element of the prior set correctly matches a correct
>>>>>>>>>>>>>> infinite behavior pattern, aborts the simulation of its
>>>>>>>>>>>>>> input on the basis and
>>>>>>>>>>>>>> returns 0.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You've quoted the code of Px above, are you really
>>>>>>>>>>>>> incapable of actually understanding it? Let's see:
>>>>>>>>>>>>>
>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that Hx(x, x)
>>>>>>>>>>>>> returns 0, so Halt_Status is set to zero
>>>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so this "if"
>>>>>>>>>>>>>> fails... HERE: goto HERE; // ... and so this line is not
>>>>>>>>>>>>>> executed ... return; // ... and we get to here.
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> So Px halts. There is no infinite behaviour pattern.
>>>>>>>>>>>> I have to update my last reply because I realized that it
>>>>>>>>>>>> was not accurate. I really only want an honest dialogue and
>>>>>>>>>>>> I incorrectly said
>>>>>>>>>>>> that you made a mistake that you did not make.
>>>>>>>>>>>
>>>>>>>>>>> Thank you for this. Yes, I was saying that if Hx(Px, Px)
>>>>>>>>>>> returns 0 then Px halts.
>>>>>>>>>>>
>>>>>>>>>>>> A simulating halt decider (SHD) only reports on the
>>>>>>>>>>>> behavior of what its
>>>>>>>>>>>> complete and correct simulation of its input would be, it
>>>>>>>>>>>> never reports
>>>>>>>>>>>> on the actual behavior of what its partial simulation is.
>>>>>>>>>>>>
>>>>>>>>>>>> If a SHD reported on whether or not its input stopped
>>>>>>>>>>>> running then in
>>>>>>>>>>>> those cases where the simulated input stopped on its own
>>>>>>>>>>>> and those cases
>>>>>>>>>>>> where the simulation was aborted the simulated input
>>>>>>>>>>>> stopped running.
>>>>>>>>>>>> This derives a correct halt decider with no discernment
>>>>>>>>>>>> every input is
>>>>>>>>>>>> reported to stop running.
>>>>>>>>>>>>
>>>>>>>>>>>> To allow a SHD to have discernment it answers a different
>>>>>>>>>>>> question: Does any correct simulation of its input reach
>>>>>>>>>>>> the final state of this
>>>>>>>>>>>> input?
>>>>>>>>>>>
>>>>>>>>>>> The snag is that Hx must always give the wrong answer for
>>>>>>>>>>> Px,
>>>>>>>>>> That is not true. Of the infinite set of Hx that correctly
>>>>>>>>>> simulate Px
>>>>>>>>>> none ever reach the final state of Px.
>>>>>>>>>
>>>>>>>>> I assume when you say "Hx that correctly simulate Px" you're
>>>>>>>>> not just talking about what Hx does internally, you are also
>>>>>>>>> saying that Hx returns the correct answer in a finite time.
>>>>>>>>> (If this is not what you mean then please spell out what you
>>>>>>>>> do mean more clearly.)
>>>>>>>>>
>>>>>>>>> As I've said before, there is not an infinite set of Hx that
>>>>>>>>> correctly simulate Px. EVERY Hx gets its corresponding Px
>>>>>>>>> wrong.
>>>>>>>>>> Every simulating halt decider must only predict the behavior
>>>>>>>>>> of what its
>>>>>>>>>> correct and complete simulation of its input would be and the
>>>>>>>>>> must not
>>>>>>>>>> report on the actual behavior of its partial simulation.
>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>> {
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> }
>>>>>>>>>> When H0 reports that its correct and complete simulation of
>>>>>>>>>> its input Infinite_Loop() would never reach the final state
>>>>>>>>>> of this simulated input it has a sound basis.
>>>>>>>>>
>>>>>>>>> Yes, there's no problem with this function and no reason why
>>>>>>>>> Hx need get it wrong. You've said that you have written an Hx
>>>>>>>>> which correctly handles this case and I have no reason to
>>>>>>>>> doubt this.
>>>>>>>>>
>>>>>>>>> The problem with Px is that it necessarily does the opposite
>>>>>>>>> of what Hx predicts it will.
>>>>>>>>
>>>>>>>> You must have not been paying hardly and attention at all.
>>>>>>>>
>>>>>>>> *The correct and complete simulation of the input to Hx(P,P) by
>>>>>>>> Hx* (a) Hx(P,P) simulates P(P) that calls a simulated Hx(P,P)
>>>>>>>> (b) that simulates P(P) that calls a simulated Hx(P,P)
>>>>>>>> (c) that simulates P(P) that calls a simulated Hx(P,P)
>>>>>>>> (d) that simulates P(P) that calls a simulated Hx(P,P)...
>>>>>>>>
>>>>>>>> No correctly simulated Px ever reaches the "if" statement that
>>>>>>>> tests the return value from Hx.
>>>>>>>>
>>>>>>>> *This fully operational code proves that*
>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>
>>>>>>>>
>>>>>>>>> Look at the code for Px - it's very short and simple. Work out
>>>>>>>>> what Px will do if Hx returns 0. Then work out what Px will do
>>>>>>>>> if Hx returns non-zero. Hx is wrong every time, isn't it?
>>>>>>>>>
>>>>>>>>> Another poster gave you an example where he explained the
>>>>>>>>> rules of a game to you but you could not predict what he
>>>>>>>>> would do, because the rules were that he would do the
>>>>>>>>> opposite of what you said. It's exactly the same situation
>>>>>>>>> here.
>>>>>>>>>> When Hx reports that its correct and complete simulation of
>>>>>>>>>> its input Px would never reach the final state of this
>>>>>>>>>> simulated input it has a sound basis.
>>>>>>>>>>
>>>>>>>>>> In neither case does it matter that neither H0 not Hx
>>>>>>>>>> actually performs
>>>>>>>>>> a correct and complete simulation of its input.
>>>>>>>>>>> that is how Px is set up. You can't get round it just by
>>>>>>>>>>> being very very careful about how Hx works.
>>>>>>>>>>>
>>>>>>>>>>>> This question also answers the classic HP question:
>>>>>>>>>>>> Does the direct execution of your input halt?
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>> x(y);
>>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Yes, if x(y) halts then Hx can identify this (I assume you
>>>>>>>>>>> meant to include "return 1;" or the like at the end).
>>>>>>>>
>>>>>>>> The problem is that it never returns a value if x(y) does not
>>>>>>>> halt. Worse still, the user doesn't know whether Hx is running
>>>>>>>> forever (meaning x(y) will not halt) or whether it just hasn't
>>>>>>>> finished yet.
>>>>>>>>
>>>>>>>> Anyone that is competent at these things knows that the above
>>>>>>>> Hx/Px combination remains infinitely recursive forever. When a
>>>>>>>> halt decider Px correctly predicts that it is necessarily
>>>>>>>> correct.
>>>>>>>>
>>>>>>>
>>>>>>> Right *THAT* Hx/Px pair has Px being non-halting, but Hx never
>>>>>>> gives the answer.
>>>>>>
>>>>>> Zero elements of the infinite set of Hx/Px pairs where Hx
>>>>>> correctly simulates its input reach their final state, thus zero
>>>>>> Px elements halt, thus every Hx that returns 0 is correct.
>>>>>>
>>>>>>
>>>>>
>>>>> Bad logic.
>>>>>
>>>>
>>>> When we ask:
>>>> Are male humans human? the answer YES
>>>> Does any Px correctly simulated by Hx halt? the answer NO
>>>
>>> The answer is YES:
>>>
>>> void Px(void (*x)())
>>> {
>>> (void) Hx(x, x);
>>> return;
>>> }
>>>
>>
>> That is not an example of a Px that when correctly simulated by Hx
>> halts, incorrect simulations do not count.
>
> It is obvious to everyone but you that Px should halt irregardless of
> whether Hx is a simulating halt decider (SHD) or not.