On 9/11/2022 2:23 PM, Mr Flibble wrote:
> On Sun, 11 Sep 2022 10:03:20 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 9/10/2022 7:56 PM, Mr Flibble wrote:
>>> On Sat, 10 Sep 2022 15:55:35 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 9/10/2022 3:29 PM, Mr Flibble wrote:
>>>>> On Sat, 10 Sep 2022 15:24:39 -0500
>>>>> olcott <none-ya@beez-wax.com> wrote:
>>>>>
>>>>>> On 9/10/2022 2:44 PM, Paul N wrote:
>>>>>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott
>>>>>>> wrote:
>>>>>>>> On 9/10/2022 2:06 PM, Paul N wrote:
>>>>>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott
>>>>>>>>> wrote:
>>>>>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
>>>>>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1, olcott
>>>>>>>>>>> wrote:
>>>>>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
>>>>>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1,
>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM UTC+1,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08 PM
>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status =
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x); if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status) HERE:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goto HERE; return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts =
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ", Hx(Px, Px)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does any complete and correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx ever stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns zero
>>>>>>>>>>>>>>>>>>>>>>>>>>> then Px halts, and if Hx returns non-zero
>>>>>>>>>>>>>>>>>>>>>>>>>>> then Px does not halt. So Hx can never do a
>>>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct simulation of Px and
>>>>>>>>>>>>>>>>>>>>>>>>>>> return the right answer.
>>>>>>>>>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
>>>>>>>>>>>>>>>>>>>>>>>>>> We are discussing the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Just to clarify, we're talking about pairs Hx
>>>>>>>>>>>>>>>>>>>>>>>>> and Px where the Px of the pair calls the Hx
>>>>>>>>>>>>>>>>>>>>>>>>> of the pair as in the code above, but we're
>>>>>>>>>>>>>>>>>>>>>>>>> not putting any restrictions on what Hx does?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> An infinite subset of
>>>>>>>>>>>>>>>>>>>>>>>>>> these do a complete and correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>> their input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the pair
>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts whether the Px of the pair
>>>>>>>>>>>>>>>>>>>>>>>>> halts, then no, they ALL get it wrong, as
>>>>>>>>>>>>>>>>>>>>>>>>> shown above.
>>>>>>>>>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all of
>>>>>>>>>>>>>>>>>>>>>>>>>> this subset would remain stuck in infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive simulation such that Px never
>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> never stops, thus Hx never returns any
>>>>>>>>>>>>>>>>>>>>>>>>>> value.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This point is moot, there are no pairs in this
>>>>>>>>>>>>>>>>>>>>>>>>> subset.
>>>>>>>>>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
>>>>>>>>>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and
>>>>>>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into ancient
>>>>>>>>>>>>>>>>>>>>>>>>>> Egyptian.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its input
>>>>>>>>>>>>>>>>>>>>>>>>>> and makes all the moves where Deep Blue beat
>>>>>>>>>>>>>>>>>>>>>>>>>> Garry Kasparov in the famous sixth match.
>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (3) An infinite subset of the *remaining
>>>>>>>>>>>>>>>>>>>>>>>>>> subsets* ignores its input and returns each
>>>>>>>>>>>>>>>>>>>>>>>>>> element of the set of integers, thus one of
>>>>>>>>>>>>>>>>>>>>>>>>>> them returns 1 and another returns 0, this
>>>>>>>>>>>>>>>>>>>>>>>>>> one is called the *wild guess halt decider*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> All of the wild guess deciders will be wrong.
>>>>>>>>>>>>>>>>>>>>>>>>> The one always guessing 0 will always be wrong
>>>>>>>>>>>>>>>>>>>>>>>>> for Px, its Px will halt. The one always
>>>>>>>>>>>>>>>>>>>>>>>>> guessing 1 will always be wrong for Px, its Px
>>>>>>>>>>>>>>>>>>>>>>>>> will not halt. Follow the code of Px if you
>>>>>>>>>>>>>>>>>>>>>>>>> don't believe me.
>>>>>>>>>>>>>>>>>>>>>>>>>> (4) One of these implements the algorithm of
>>>>>>>>>>>>>>>>>>>>>>>>>> my simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When it is the job of the halt decider to
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predict whether or not its correct
>>>>>>>>>>>>>>>>>>>>>>>>>> and complete simulation of its input would
>>>>>>>>>>>>>>>>>>>>>>>>>> halt even the *wild guess halt decider*
>>>>>>>>>>>>>>>>>>>>>>>>>> element of subset (3) is correct:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will not
>>>>>>>>>>>>>>>>>>>>>>>>> halt, but Px does halt. Try running it!
>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px by
>>>>>>>>>>>>>>>>>>>>>>>> Hx never halt therefore any damn thing that
>>>>>>>>>>>>>>>>>>>>>>>> says: "all correct and complete simulations of
>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx never halt therefore" *IS NECESSARILY
>>>>>>>>>>>>>>>>>>>>>>>> CORRECT*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Firstly, I see that you have ignored almost all
>>>>>>>>>>>>>>>>>>>>>>> of what I wrote and are headed off in a
>>>>>>>>>>>>>>>>>>>>>>> different direction. I wonder why?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So you don't understand the above point that
>>>>>>>>>>>>>>>>>>>>>> applies to every program that return 0?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If you mean the four lines just above, no, I am
>>>>>>>>>>>>>>>>>>>>> not clear what they say. I'm not even sure you
>>>>>>>>>>>>>>>>>>>>> know what they say. I think you need some words
>>>>>>>>>>>>>>>>>>>>> after the second "therefore" to make them make
>>>>>>>>>>>>>>>>>>>>> sense.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>> The code for Px is fully specified. The code for Hx
>>>>>>>>>>>>>>>>>>>> is the infinite set of every C function that takes
>>>>>>>>>>>>>>>>>>>> a pair of ptr arguments. These arguments can be
>>>>>>>>>>>>>>>>>>>> ignored, summed together, multiplied together,
>>>>>>>>>>>>>>>>>>>> simulated, or anything else. One element of Hx
>>>>>>>>>>>>>>>>>>>> ignores its arguments, translates the Lord's prayer
>>>>>>>>>>>>>>>>>>>> into ancient Egyptian and returns 56.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A subset of these C functions perform a correct
>>>>>>>>>>>>>>>>>>>> partial or complete simulation of their input. In
>>>>>>>>>>>>>>>>>>>> none of the elements of this set does Px ever reach
>>>>>>>>>>>>>>>>>>>> its final state.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A subset of the original set return a value of 0,
>>>>>>>>>>>>>>>>>>>> which turns out to be the correct answer to the
>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Does there exist any element of the infinite set of
>>>>>>>>>>>>>>>>>>>> Hx/Px pairs such that Px correctly simulated by Hx
>>>>>>>>>>>>>>>>>>>> reaches the final state of Px?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> One element of the prior set correctly matches a
>>>>>>>>>>>>>>>>>>>> correct infinite behavior pattern, aborts the
>>>>>>>>>>>>>>>>>>>> simulation of its input on the basis and returns
>>>>>>>>>>>>>>>>>>>> 0.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You've quoted the code of Px above, are you really
>>>>>>>>>>>>>>>>>>> incapable of actually understanding it? Let's see:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that Hx(x, x)
>>>>>>>>>>>>>>>>>>> returns 0, so Halt_Status is set to zero
>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so this
>>>>>>>>>>>>>>>>>>>> "if" fails... HERE: goto HERE; // ... and so this
>>>>>>>>>>>>>>>>>>>> line is not executed ... return; // ... and we get
>>>>>>>>>>>>>>>>>>>> to here. }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So Px halts. There is no infinite behaviour
>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>> I have to update my last reply because I realized
>>>>>>>>>>>>>>>>>> that it was not accurate. I really only want an
>>>>>>>>>>>>>>>>>> honest dialogue and I incorrectly said that you made
>>>>>>>>>>>>>>>>>> a mistake that you did not make.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thank you for this. Yes, I was saying that if Hx(Px,
>>>>>>>>>>>>>>>>> Px) returns 0 then Px halts.
>>>>>>>>>>>>>>>>>> A simulating halt decider (SHD) only reports on the
>>>>>>>>>>>>>>>>>> behavior of what its complete and correct simulation
>>>>>>>>>>>>>>>>>> of its input would be, it never reports on the actual
>>>>>>>>>>>>>>>>>> behavior of what its partial simulation is.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If a SHD reported on whether or not its input stopped
>>>>>>>>>>>>>>>>>> running then in those cases where the simulated input
>>>>>>>>>>>>>>>>>> stopped on its own and those cases where the
>>>>>>>>>>>>>>>>>> simulation was aborted the simulated input stopped
>>>>>>>>>>>>>>>>>> running. This derives a correct halt decider with no
>>>>>>>>>>>>>>>>>> discernment every input is reported to stop running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> To allow a SHD to have discernment it answers a
>>>>>>>>>>>>>>>>>> different question: Does any correct simulation of
>>>>>>>>>>>>>>>>>> its input reach the final state of this input?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The snag is that Hx must always give the wrong answer
>>>>>>>>>>>>>>>>> for Px,
>>>>>>>>>>>>>>>> That is not true. Of the infinite set of Hx that
>>>>>>>>>>>>>>>> correctly simulate Px none ever reach the final state
>>>>>>>>>>>>>>>> of Px.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I assume when you say "Hx that correctly simulate Px"
>>>>>>>>>>>>>>> you're not just talking about what Hx does internally,
>>>>>>>>>>>>>>> you are also saying that Hx returns the correct answer
>>>>>>>>>>>>>>> in a finite time. (If this is not what you mean then
>>>>>>>>>>>>>>> please spell out what you do mean more clearly.)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> As I've said before, there is not an infinite set of Hx
>>>>>>>>>>>>>>> that correctly simulate Px. EVERY Hx gets its
>>>>>>>>>>>>>>> corresponding Px wrong.
>>>>>>>>>>>>>>>> Every simulating halt decider must only predict the
>>>>>>>>>>>>>>>> behavior of what its correct and complete simulation of
>>>>>>>>>>>>>>>> its input would be and the must not report on the
>>>>>>>>>>>>>>>> actual behavior of its partial simulation. void
>>>>>>>>>>>>>>>> Infinite_Loop() {
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> When H0 reports that its correct and complete
>>>>>>>>>>>>>>>> simulation of its input Infinite_Loop() would never
>>>>>>>>>>>>>>>> reach the final state of this simulated input it has a
>>>>>>>>>>>>>>>> sound basis.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, there's no problem with this function and no reason
>>>>>>>>>>>>>>> why Hx need get it wrong. You've said that you have
>>>>>>>>>>>>>>> written an Hx which correctly handles this case and I
>>>>>>>>>>>>>>> have no reason to doubt this.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The problem with Px is that it necessarily does the
>>>>>>>>>>>>>>> opposite of what Hx predicts it will.
>>>>>>>>>>>>>> You must have not been paying hardly and attention at
>>>>>>>>>>>>>> all.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *The correct and complete simulation of the input to
>>>>>>>>>>>>>> Hx(P,P) by Hx* (a) Hx(P,P) simulates P(P) that calls a
>>>>>>>>>>>>>> simulated Hx(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>> simulated Hx(P,P) (c) that simulates P(P) that calls a
>>>>>>>>>>>>>> simulated Hx(P,P) (d) that simulates P(P) that calls a
>>>>>>>>>>>>>> simulated Hx(P,P)...
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nonsense. You've told us many times that Hx does not
>>>>>>>>>>>>> behave like this. So it is not a correct simulation to
>>>>>>>>>>>>> pretend that it does.
>>>>>>>>>>>> Hx is not the same as H. As I have told you several times
>>>>>>>>>>>> now, the Hx/Px pairs are the infinite set of every encoding
>>>>>>>>>>>> of Hx. I am going to stop right here and not proceed to
>>>>>>>>>>>> another point until you fully understand and accept this
>>>>>>>>>>>> point.
>>>>>>>>>>>
>>>>>>>>>>> OK then. You are saying that there are infinitely many
>>>>>>>>>>> possible functions Hx, and that of these, infinitely many do
>>>>>>>>>>> a correct simulation of the corresponding Px. I am saying
>>>>>>>>>>> that while here are infinitely many possible functions Hx,
>>>>>>>>>>> none of them do a correct simulation of the corresponding
>>>>>>>>>>> Px.
>>>>>>>>>>
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>> // An Infinite number of different halting computations can
>>>>>>>>>> precede this: Simulate(x,y);
>>>>>>>>>> return 1;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Hx(Px,Px);
>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> You've completely failed to answer any of the questions!
>>>>>>>>>
>>>>>>>>> If you accept that of the infinitely many possible functions
>>>>>>>>> Hx, none of them do a correct simulation
>>>>>>>> It is stipulated that I just provided such a function.
>>>>>>>> Here it is again named differently:
>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>> {
>>>>>>>> x86_emulate(x,y);
>>>>>>>> return 1;
>>>>>>>> }
>>>>>>>>
>>>>>>>> Hx function that is computationally equivalent to the above:
>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>> {
>>>>>>>> x(y);
>>>>>>>> return 1;
>>>>>>>> }
>>>>>>>
>>>>>>> Fair enough. I ask you the questions a second time and you just
>>>>>>> snip them again. You've provided one function which simply calls
>>>>>>> another, unshown, function, so we can't have a clue what it
>>>>>>> does. You've also said it is "computationally equivalent"
>>>>>>> (whatever that means) to a function which won't return a value.
>>>>>>> I can only assume that you know full well that no functions
>>>>>>> provide a correct result for Px and that you are simply trying
>>>>>>> to bluff. There's no reason to further try to persuade you that
>>>>>>> you're wrong, you apparently know it already.
>>>>>>
>>>>>> So you still don't understand that all simulating halt deciders
>>>>>> PREDICT that their complete simulation of their input would never
>>>>>> reach the final state of this simulated input without actually
>>>>>> performing a complete simulation of this non-terminating input?
>>>>>>
>>>>>> *I have told you this dozens of times and you still don't get
>>>>>> it*?
>>>>>>
>>>>>> void Infinite_Loop()
>>>>>> {
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>> }
>>>>>>
>>>>>> _Infinite_Loop()
>>>>>> [00001102](01) 55 push ebp
>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>> [00001107](01) 5d pop ebp
>>>>>> [00001108](01) c3 ret
>>>>>> Size in bytes:(0007) [00001108]
>>>>>>
>>>>>> H0: Begin Simulation Execution Trace Stored at:211fac
>>>>>> [00001102][00211f9c][00211fa0] 55 push ebp
>>>>>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>
>>>>>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF _Infinite_Loop() YET
>>>>>> STILL CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION WOULD
>>>>>> NEVER HALT.
>>>>>
>>>>> Detecting non-halting is different to aborting a simulation
>>>>> because the decider is incorrectly designed using recursion.
>>>>>
>>>>> /Flibble
>>>>>
>>>>>
>>>>
>>>> *It* is easy to verify that HH(PP,PP) is correctly designed to do
>>>> recursive simulation. This was the hardest part of the entire
>>>> design. https://liarparadox.org/2022_09_07.zip
>>>>
>>>> Each emulation requires its own process context including its own
>>>> stack space.
>>>
>>> Recursive simulation is the wrong approach as a halting decider is
>>> supposed to always return a result to its caller. The Flibble
>>> Signaling Halt Decider (tm) is a simulating halt decider that does
>>> not rely on recursion.
>>>
>>> /Flibble
>>>
>>
>> If an input specifies infinitely recursive simulation then its
>> correct simulation requires this.
>
> That isn't what I said. Again: a decider does not have to be recursive
> in order to simulate something that is recursive.

On Sun, 11 Sep 2022 14:40:40 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/11/2022 2:23 PM, Mr Flibble wrote:
> > On Sun, 11 Sep 2022 10:03:20 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 9/10/2022 7:56 PM, Mr Flibble wrote:
> >>> On Sat, 10 Sep 2022 15:55:35 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 9/10/2022 3:29 PM, Mr Flibble wrote:
> >>>>> On Sat, 10 Sep 2022 15:24:39 -0500
> >>>>> olcott <none-ya@beez-wax.com> wrote:
> >>>>>
> >>>>>> On 9/10/2022 2:44 PM, Paul N wrote:
> >>>>>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott
> >>>>>>> wrote:
> >>>>>>>> On 9/10/2022 2:06 PM, Paul N wrote:
> >>>>>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott
> >>>>>>>>> wrote:
> >>>>>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
> >>>>>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1,
> >>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
> >>>>>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1,
> >>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
> >>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM UTC+1,
> >>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM
> >>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08 PM
> >>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM
> >>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44
> >>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56 PM,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status =
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x); if
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status) HERE:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goto HERE; return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = ", Hx(Px, Px));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Does any complete and correct simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> of Px by Hx ever stop running?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns zero
> >>>>>>>>>>>>>>>>>>>>>>>>>>> then Px halts, and if Hx returns non-zero
> >>>>>>>>>>>>>>>>>>>>>>>>>>> then Px does not halt. So Hx can never do
> >>>>>>>>>>>>>>>>>>>>>>>>>>> a complete and correct simulation of Px
> >>>>>>>>>>>>>>>>>>>>>>>>>>> and return the right answer.
> >>>>>>>>>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
> >>>>>>>>>>>>>>>>>>>>>>>>>> We are discussing the infinite set of Hx/Px
> >>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Just to clarify, we're talking about pairs
> >>>>>>>>>>>>>>>>>>>>>>>>> Hx and Px where the Px of the pair calls
> >>>>>>>>>>>>>>>>>>>>>>>>> the Hx of the pair as in the code above,
> >>>>>>>>>>>>>>>>>>>>>>>>> but we're not putting any restrictions on
> >>>>>>>>>>>>>>>>>>>>>>>>> what Hx does?
> >>>>>>>>>>>>>>>>>>>>>>>>>> An infinite subset of
> >>>>>>>>>>>>>>>>>>>>>>>>>> these do a complete and correct simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>> of their input.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the pair
> >>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts whether the Px of the
> >>>>>>>>>>>>>>>>>>>>>>>>> pair halts, then no, they ALL get it wrong,
> >>>>>>>>>>>>>>>>>>>>>>>>> as shown above.
> >>>>>>>>>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all of
> >>>>>>>>>>>>>>>>>>>>>>>>>> this subset would remain stuck in
> >>>>>>>>>>>>>>>>>>>>>>>>>> infinitely recursive simulation such that
> >>>>>>>>>>>>>>>>>>>>>>>>>> Px never reaches its final state and the
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulation never stops, thus Hx never
> >>>>>>>>>>>>>>>>>>>>>>>>>> returns any value.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> This point is moot, there are no pairs in
> >>>>>>>>>>>>>>>>>>>>>>>>> this subset.
> >>>>>>>>>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
> >>>>>>>>>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and
> >>>>>>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into ancient
> >>>>>>>>>>>>>>>>>>>>>>>>>> Egyptian.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its input
> >>>>>>>>>>>>>>>>>>>>>>>>>> and makes all the moves where Deep Blue
> >>>>>>>>>>>>>>>>>>>>>>>>>> beat Garry Kasparov in the famous sixth
> >>>>>>>>>>>>>>>>>>>>>>>>>> match.
> >>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> (3) An infinite subset of the *remaining
> >>>>>>>>>>>>>>>>>>>>>>>>>> subsets* ignores its input and returns each
> >>>>>>>>>>>>>>>>>>>>>>>>>> element of the set of integers, thus one of
> >>>>>>>>>>>>>>>>>>>>>>>>>> them returns 1 and another returns 0, this
> >>>>>>>>>>>>>>>>>>>>>>>>>> one is called the *wild guess halt
> >>>>>>>>>>>>>>>>>>>>>>>>>> decider*
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> All of the wild guess deciders will be
> >>>>>>>>>>>>>>>>>>>>>>>>> wrong. The one always guessing 0 will
> >>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will halt.
> >>>>>>>>>>>>>>>>>>>>>>>>> The one always guessing 1 will always be
> >>>>>>>>>>>>>>>>>>>>>>>>> wrong for Px, its Px will not halt. Follow
> >>>>>>>>>>>>>>>>>>>>>>>>> the code of Px if you don't believe me.
> >>>>>>>>>>>>>>>>>>>>>>>>>> (4) One of these implements the algorithm
> >>>>>>>>>>>>>>>>>>>>>>>>>> of my simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> When it is the job of the halt decider to
> >>>>>>>>>>>>>>>>>>>>>>>>>> correctly predict whether or not its
> >>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>>> input would halt even the *wild guess halt
> >>>>>>>>>>>>>>>>>>>>>>>>>> decider* element of subset (3) is correct:
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will not
> >>>>>>>>>>>>>>>>>>>>>>>>> halt, but Px does halt. Try running it!
> >>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px by
> >>>>>>>>>>>>>>>>>>>>>>>> Hx never halt therefore any damn thing that
> >>>>>>>>>>>>>>>>>>>>>>>> says: "all correct and complete simulations
> >>>>>>>>>>>>>>>>>>>>>>>> of Px by Hx never halt therefore" *IS
> >>>>>>>>>>>>>>>>>>>>>>>> NECESSARILY CORRECT*
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Firstly, I see that you have ignored almost
> >>>>>>>>>>>>>>>>>>>>>>> all of what I wrote and are headed off in a
> >>>>>>>>>>>>>>>>>>>>>>> different direction. I wonder why?
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> So you don't understand the above point that
> >>>>>>>>>>>>>>>>>>>>>> applies to every program that return 0?
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> If you mean the four lines just above, no, I am
> >>>>>>>>>>>>>>>>>>>>> not clear what they say. I'm not even sure you
> >>>>>>>>>>>>>>>>>>>>> know what they say. I think you need some words
> >>>>>>>>>>>>>>>>>>>>> after the second "therefore" to make them make
> >>>>>>>>>>>>>>>>>>>>> sense.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>> The code for Px is fully specified. The code for
> >>>>>>>>>>>>>>>>>>>> Hx is the infinite set of every C function that
> >>>>>>>>>>>>>>>>>>>> takes a pair of ptr arguments. These arguments
> >>>>>>>>>>>>>>>>>>>> can be ignored, summed together, multiplied
> >>>>>>>>>>>>>>>>>>>> together, simulated, or anything else. One
> >>>>>>>>>>>>>>>>>>>> element of Hx ignores its arguments, translates
> >>>>>>>>>>>>>>>>>>>> the Lord's prayer into ancient Egyptian and
> >>>>>>>>>>>>>>>>>>>> returns 56.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> A subset of these C functions perform a correct
> >>>>>>>>>>>>>>>>>>>> partial or complete simulation of their input. In
> >>>>>>>>>>>>>>>>>>>> none of the elements of this set does Px ever
> >>>>>>>>>>>>>>>>>>>> reach its final state.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> A subset of the original set return a value of 0,
> >>>>>>>>>>>>>>>>>>>> which turns out to be the correct answer to the
> >>>>>>>>>>>>>>>>>>>> question:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Does there exist any element of the infinite set
> >>>>>>>>>>>>>>>>>>>> of Hx/Px pairs such that Px correctly simulated
> >>>>>>>>>>>>>>>>>>>> by Hx reaches the final state of Px?
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> One element of the prior set correctly matches a
> >>>>>>>>>>>>>>>>>>>> correct infinite behavior pattern, aborts the
> >>>>>>>>>>>>>>>>>>>> simulation of its input on the basis and returns
> >>>>>>>>>>>>>>>>>>>> 0.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> You've quoted the code of Px above, are you really
> >>>>>>>>>>>>>>>>>>> incapable of actually understanding it? Let's see:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that Hx(x,
> >>>>>>>>>>>>>>>>>>> x) returns 0, so Halt_Status is set to zero
> >>>>>>>>>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so this
> >>>>>>>>>>>>>>>>>>>> "if" fails... HERE: goto HERE; // ... and so this
> >>>>>>>>>>>>>>>>>>>> line is not executed ... return; // ... and we
> >>>>>>>>>>>>>>>>>>>> get to here. }
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> So Px halts. There is no infinite behaviour
> >>>>>>>>>>>>>>>>>>> pattern.
> >>>>>>>>>>>>>>>>>> I have to update my last reply because I realized
> >>>>>>>>>>>>>>>>>> that it was not accurate. I really only want an
> >>>>>>>>>>>>>>>>>> honest dialogue and I incorrectly said that you
> >>>>>>>>>>>>>>>>>> made a mistake that you did not make.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Thank you for this. Yes, I was saying that if Hx(Px,
> >>>>>>>>>>>>>>>>> Px) returns 0 then Px halts.
> >>>>>>>>>>>>>>>>>> A simulating halt decider (SHD) only reports on the
> >>>>>>>>>>>>>>>>>> behavior of what its complete and correct
> >>>>>>>>>>>>>>>>>> simulation of its input would be, it never reports
> >>>>>>>>>>>>>>>>>> on the actual behavior of what its partial
> >>>>>>>>>>>>>>>>>> simulation is.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> If a SHD reported on whether or not its input
> >>>>>>>>>>>>>>>>>> stopped running then in those cases where the
> >>>>>>>>>>>>>>>>>> simulated input stopped on its own and those cases
> >>>>>>>>>>>>>>>>>> where the simulation was aborted the simulated
> >>>>>>>>>>>>>>>>>> input stopped running. This derives a correct halt
> >>>>>>>>>>>>>>>>>> decider with no discernment every input is
> >>>>>>>>>>>>>>>>>> reported to stop running.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> To allow a SHD to have discernment it answers a
> >>>>>>>>>>>>>>>>>> different question: Does any correct simulation of
> >>>>>>>>>>>>>>>>>> its input reach the final state of this input?
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The snag is that Hx must always give the wrong
> >>>>>>>>>>>>>>>>> answer for Px,
> >>>>>>>>>>>>>>>> That is not true. Of the infinite set of Hx that
> >>>>>>>>>>>>>>>> correctly simulate Px none ever reach the final state
> >>>>>>>>>>>>>>>> of Px.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> I assume when you say "Hx that correctly simulate Px"
> >>>>>>>>>>>>>>> you're not just talking about what Hx does internally,
> >>>>>>>>>>>>>>> you are also saying that Hx returns the correct answer
> >>>>>>>>>>>>>>> in a finite time. (If this is not what you mean then
> >>>>>>>>>>>>>>> please spell out what you do mean more clearly.)
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> As I've said before, there is not an infinite set of
> >>>>>>>>>>>>>>> Hx that correctly simulate Px. EVERY Hx gets its
> >>>>>>>>>>>>>>> corresponding Px wrong.
> >>>>>>>>>>>>>>>> Every simulating halt decider must only predict the
> >>>>>>>>>>>>>>>> behavior of what its correct and complete simulation
> >>>>>>>>>>>>>>>> of its input would be and the must not report on the
> >>>>>>>>>>>>>>>> actual behavior of its partial simulation. void
> >>>>>>>>>>>>>>>> Infinite_Loop() {
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>> When H0 reports that its correct and complete
> >>>>>>>>>>>>>>>> simulation of its input Infinite_Loop() would never
> >>>>>>>>>>>>>>>> reach the final state of this simulated input it has
> >>>>>>>>>>>>>>>> a sound basis.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Yes, there's no problem with this function and no
> >>>>>>>>>>>>>>> reason why Hx need get it wrong. You've said that you
> >>>>>>>>>>>>>>> have written an Hx which correctly handles this case
> >>>>>>>>>>>>>>> and I have no reason to doubt this.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> The problem with Px is that it necessarily does the
> >>>>>>>>>>>>>>> opposite of what Hx predicts it will.
> >>>>>>>>>>>>>> You must have not been paying hardly and attention at
> >>>>>>>>>>>>>> all.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> *The correct and complete simulation of the input to
> >>>>>>>>>>>>>> Hx(P,P) by Hx* (a) Hx(P,P) simulates P(P) that calls a
> >>>>>>>>>>>>>> simulated Hx(P,P) (b) that simulates P(P) that calls a
> >>>>>>>>>>>>>> simulated Hx(P,P) (c) that simulates P(P) that calls a
> >>>>>>>>>>>>>> simulated Hx(P,P) (d) that simulates P(P) that calls a
> >>>>>>>>>>>>>> simulated Hx(P,P)...
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Nonsense. You've told us many times that Hx does not
> >>>>>>>>>>>>> behave like this. So it is not a correct simulation to
> >>>>>>>>>>>>> pretend that it does.
> >>>>>>>>>>>> Hx is not the same as H. As I have told you several times
> >>>>>>>>>>>> now, the Hx/Px pairs are the infinite set of every
> >>>>>>>>>>>> encoding of Hx. I am going to stop right here and not
> >>>>>>>>>>>> proceed to another point until you fully understand and
> >>>>>>>>>>>> accept this point.
> >>>>>>>>>>>
> >>>>>>>>>>> OK then. You are saying that there are infinitely many
> >>>>>>>>>>> possible functions Hx, and that of these, infinitely many
> >>>>>>>>>>> do a correct simulation of the corresponding Px. I am
> >>>>>>>>>>> saying that while here are infinitely many possible
> >>>>>>>>>>> functions Hx, none of them do a correct simulation of the
> >>>>>>>>>>> corresponding Px.
> >>>>>>>>>>
> >>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>> {
> >>>>>>>>>> // An Infinite number of different halting computations can
> >>>>>>>>>> precede this: Simulate(x,y);
> >>>>>>>>>> return 1;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>> Hx(Px,Px);
> >>>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> You've completely failed to answer any of the questions!
> >>>>>>>>>
> >>>>>>>>> If you accept that of the infinitely many possible functions
> >>>>>>>>> Hx, none of them do a correct simulation
> >>>>>>>> It is stipulated that I just provided such a function.
> >>>>>>>> Here it is again named differently:
> >>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>> {
> >>>>>>>> x86_emulate(x,y);
> >>>>>>>> return 1;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> Hx function that is computationally equivalent to the above:
> >>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>> {
> >>>>>>>> x(y);
> >>>>>>>> return 1;
> >>>>>>>> }
> >>>>>>>
> >>>>>>> Fair enough. I ask you the questions a second time and you
> >>>>>>> just snip them again. You've provided one function which
> >>>>>>> simply calls another, unshown, function, so we can't have a
> >>>>>>> clue what it does. You've also said it is "computationally
> >>>>>>> equivalent" (whatever that means) to a function which won't
> >>>>>>> return a value. I can only assume that you know full well
> >>>>>>> that no functions provide a correct result for Px and that
> >>>>>>> you are simply trying to bluff. There's no reason to further
> >>>>>>> try to persuade you that you're wrong, you apparently know it
> >>>>>>> already.
> >>>>>>
> >>>>>> So you still don't understand that all simulating halt deciders
> >>>>>> PREDICT that their complete simulation of their input would
> >>>>>> never reach the final state of this simulated input without
> >>>>>> actually performing a complete simulation of this
> >>>>>> non-terminating input?
> >>>>>>
> >>>>>> *I have told you this dozens of times and you still don't get
> >>>>>> it*?
> >>>>>>
> >>>>>> void Infinite_Loop()
> >>>>>> {
> >>>>>> HERE: goto HERE;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>> }
> >>>>>>
> >>>>>> _Infinite_Loop()
> >>>>>> [00001102](01) 55 push ebp
> >>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>> [00001107](01) 5d pop ebp
> >>>>>> [00001108](01) c3 ret
> >>>>>> Size in bytes:(0007) [00001108]
> >>>>>>
> >>>>>> H0: Begin Simulation Execution Trace Stored at:211fac
> >>>>>> [00001102][00211f9c][00211fa0] 55 push ebp
> >>>>>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
> >>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> >>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> >>>>>> H0: Infinite Loop Detected Simulation Stopped
> >>>>>>
> >>>>>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF _Infinite_Loop()
> >>>>>> YET STILL CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION
> >>>>>> WOULD NEVER HALT.
> >>>>>
> >>>>> Detecting non-halting is different to aborting a simulation
> >>>>> because the decider is incorrectly designed using recursion.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>>
> >>>>
> >>>> *It* is easy to verify that HH(PP,PP) is correctly designed to do
> >>>> recursive simulation. This was the hardest part of the entire
> >>>> design. https://liarparadox.org/2022_09_07.zip
> >>>>
> >>>> Each emulation requires its own process context including its own
> >>>> stack space.
> >>>
> >>> Recursive simulation is the wrong approach as a halting decider is
> >>> supposed to always return a result to its caller. The Flibble
> >>> Signaling Halt Decider (tm) is a simulating halt decider that does
> >>> not rely on recursion.
> >>>
> >>> /Flibble
> >>>
> >>
> >> If an input specifies infinitely recursive simulation then its
> >> correct simulation requires this.
> >
> > That isn't what I said. Again: a decider does not have to be
> > recursive in order to simulate something that is recursive.
>
> If an input to a simulator specifies recursive simulation then any
> simulator that does not implement recursive simulation is incorrect.

On 9/11/22 3:38 PM, olcott wrote:
> On 9/11/2022 2:06 PM, Richard Damon wrote:
>> On 9/11/22 2:52 PM, olcott wrote:
>>> On 9/11/2022 1:38 PM, Richard Damon wrote:
>>>> On 9/11/22 2:13 PM, olcott wrote:
>>>>> On 9/11/2022 12:29 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/11/22 1:20 PM, olcott wrote:
>>>>>>> On 9/11/2022 12:00 PM, Richard Damon wrote:
>>>>>>>> On 9/11/22 12:44 PM, olcott wrote:
>>>>>>>>> On 9/11/2022 11:28 AM, Paul N wrote:
>>>>>>>>>> On Sunday, September 11, 2022 at 4:48:22 PM UTC+1, olcott wrote:
>>>>>>>>>>> On 9/11/2022 10:23 AM, Paul N wrote:
>>>>>>>>>>>> On Saturday, September 10, 2022 at 9:24:43 PM UTC+1, olcott
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> On 9/10/2022 2:44 PM, Paul N wrote:
>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1,
>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>> On 9/10/2022 2:06 PM, Paul N wrote:
>>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1,
>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1,
>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM
>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:50:20 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:09:44 AM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does any complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx ever stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> zero then Px halts, and if Hx returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-zero then Px does not halt. So Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can never do a complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px and return the right
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are discussing the infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just to clarify, we're talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs Hx and Px where the Px of the pair
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the Hx of the pair as in the code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> above, but we're not putting any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> restrictions on what Hx does?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> An infinite subset of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these do a complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of their input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pair correctly predicts whether the Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the pair halts, then no, they ALL get
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it wrong, as shown above.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this subset would remain
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stuck in infinitely recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation such that Px never reaches its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state and the simulation never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stops, thus Hx never returns any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This point is moot, there are no pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in this subset.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ancient Egyptian.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and makes all the moves where
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deep Blue beat Garry Kasparov in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> famous sixth match.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) An infinite subset of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *remaining subsets* ignores its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns each element of the set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> integers, thus one of them returns 1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and another returns 0, this one is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called the *wild guess halt decider*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of the wild guess deciders will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. The one always guessing 0 will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt. The one always guessing 1 will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt. Follow the code of Px if you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> believe me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (4) One of these implements the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm of my simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When it is the job of the halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to correctly predict whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not its correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would halt even the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *wild guess halt decider* element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset (3) is correct:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt, but Px does halt. Try running it!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx never halt therefore
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any damn thing that says:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "all correct and complete simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx never halt therefore"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Firstly, I see that you have ignored
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> almost all of what I wrote and are headed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> off in a different direction. I wonder why?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you don't understand the above point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that applies to every program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that return 0?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you mean the four lines just above, no, I
>>>>>>>>>>>>>>>>>>>>>>>>>>>> am not clear what they say. I'm not even
>>>>>>>>>>>>>>>>>>>>>>>>>>>> sure you know what they say. I think you
>>>>>>>>>>>>>>>>>>>>>>>>>>>> need some words after the second "therefore"
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to make them make sense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>> The code for Px is fully specified. The code
>>>>>>>>>>>>>>>>>>>>>>>>>>> for Hx is the infinite set
>>>>>>>>>>>>>>>>>>>>>>>>>>> of every C function that takes a pair of ptr
>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments. These arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>> can be ignored, summed together, multiplied
>>>>>>>>>>>>>>>>>>>>>>>>>>> together, simulated, or
>>>>>>>>>>>>>>>>>>>>>>>>>>> anything else. One element of Hx ignores its
>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments, translates the
>>>>>>>>>>>>>>>>>>>>>>>>>>> Lord's prayer into ancient Egyptian and
>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 56.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of these C functions perform a
>>>>>>>>>>>>>>>>>>>>>>>>>>> correct partial or complete
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of their input. In none of the
>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of this set does Px
>>>>>>>>>>>>>>>>>>>>>>>>>>> ever reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of the original set return a value
>>>>>>>>>>>>>>>>>>>>>>>>>>> of 0, which turns out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer to the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Does there exist any element of the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such
>>>>>>>>>>>>>>>>>>>>>>>>>>> that Px correctly simulated by Hx reaches the
>>>>>>>>>>>>>>>>>>>>>>>>>>> final state of Px?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> One element of the prior set correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern, aborts the simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>> its input on the basis and
>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You've quoted the code of Px above, are you
>>>>>>>>>>>>>>>>>>>>>>>>>> really incapable of actually understanding it?
>>>>>>>>>>>>>>>>>>>>>>>>>> Let's see:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that
>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x) returns 0, so Halt_Status is set to zero
>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so
>>>>>>>>>>>>>>>>>>>>>>>>>>> this "if" fails...
>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE; // ... and so this line is
>>>>>>>>>>>>>>>>>>>>>>>>>>> not executed ...
>>>>>>>>>>>>>>>>>>>>>>>>>>> return; // ... and we get to here.
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So Px halts. There is no infinite behaviour
>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>> I have to update my last reply because I
>>>>>>>>>>>>>>>>>>>>>>>>> realized that it was not
>>>>>>>>>>>>>>>>>>>>>>>>> accurate. I really only want an honest dialogue
>>>>>>>>>>>>>>>>>>>>>>>>> and I incorrectly said
>>>>>>>>>>>>>>>>>>>>>>>>> that you made a mistake that you did not make.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Thank you for this. Yes, I was saying that if
>>>>>>>>>>>>>>>>>>>>>>>> Hx(Px, Px) returns 0 then Px halts.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider (SHD) only reports on
>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of what its
>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>> would be, it never reports
>>>>>>>>>>>>>>>>>>>>>>>>> on the actual behavior of what its partial
>>>>>>>>>>>>>>>>>>>>>>>>> simulation is.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If a SHD reported on whether or not its input
>>>>>>>>>>>>>>>>>>>>>>>>> stopped running then in
>>>>>>>>>>>>>>>>>>>>>>>>> those cases where the simulated input stopped
>>>>>>>>>>>>>>>>>>>>>>>>> on its own and those cases
>>>>>>>>>>>>>>>>>>>>>>>>> where the simulation was aborted the simulated
>>>>>>>>>>>>>>>>>>>>>>>>> input stopped running.
>>>>>>>>>>>>>>>>>>>>>>>>> This derives a correct halt decider with no
>>>>>>>>>>>>>>>>>>>>>>>>> discernment every input is
>>>>>>>>>>>>>>>>>>>>>>>>> reported to stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> To allow a SHD to have discernment it answers a
>>>>>>>>>>>>>>>>>>>>>>>>> different question:
>>>>>>>>>>>>>>>>>>>>>>>>> Does any correct simulation of its input reach
>>>>>>>>>>>>>>>>>>>>>>>>> the final state of this
>>>>>>>>>>>>>>>>>>>>>>>>> input?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The snag is that Hx must always give the wrong
>>>>>>>>>>>>>>>>>>>>>>>> answer for Px,
>>>>>>>>>>>>>>>>>>>>>>> That is not true. Of the infinite set of Hx that
>>>>>>>>>>>>>>>>>>>>>>> correctly simulate Px
>>>>>>>>>>>>>>>>>>>>>>> none ever reach the final state of Px.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I assume when you say "Hx that correctly simulate
>>>>>>>>>>>>>>>>>>>>>> Px" you're not just talking about what Hx does
>>>>>>>>>>>>>>>>>>>>>> internally, you are also saying that Hx returns
>>>>>>>>>>>>>>>>>>>>>> the correct answer in a finite time. (If this is
>>>>>>>>>>>>>>>>>>>>>> not what you mean then please spell out what you
>>>>>>>>>>>>>>>>>>>>>> do mean more clearly.)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> As I've said before, there is not an infinite set
>>>>>>>>>>>>>>>>>>>>>> of Hx that correctly simulate Px. EVERY Hx gets
>>>>>>>>>>>>>>>>>>>>>> its corresponding Px wrong.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Every simulating halt decider must only predict
>>>>>>>>>>>>>>>>>>>>>>> the behavior of what its
>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its input
>>>>>>>>>>>>>>>>>>>>>>> would be and the must not
>>>>>>>>>>>>>>>>>>>>>>> report on the actual behavior of its partial
>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>> When H0 reports that its correct and complete
>>>>>>>>>>>>>>>>>>>>>>> simulation of its input
>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() would never reach the final state
>>>>>>>>>>>>>>>>>>>>>>> of this simulated
>>>>>>>>>>>>>>>>>>>>>>> input it has a sound basis.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Yes, there's no problem with this function and no
>>>>>>>>>>>>>>>>>>>>>> reason why Hx need get it wrong. You've said that
>>>>>>>>>>>>>>>>>>>>>> you have written an Hx which correctly handles
>>>>>>>>>>>>>>>>>>>>>> this case and I have no reason to doubt this.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The problem with Px is that it necessarily does
>>>>>>>>>>>>>>>>>>>>>> the opposite of what Hx predicts it will.
>>>>>>>>>>>>>>>>>>>>> You must have not been paying hardly and attention
>>>>>>>>>>>>>>>>>>>>> at all.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>> to Hx(P,P) by Hx*
>>>>>>>>>>>>>>>>>>>>> (a) Hx(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>> Hx(P,P)
>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated Hx(P,P)
>>>>>>>>>>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated Hx(P,P)
>>>>>>>>>>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>> Hx(P,P)...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nonsense. You've told us many times that Hx does not
>>>>>>>>>>>>>>>>>>>> behave like this. So it is not a correct simulation
>>>>>>>>>>>>>>>>>>>> to pretend that it does.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Hx is not the same as H. As I have told you several
>>>>>>>>>>>>>>>>>>> times now, the Hx/Px
>>>>>>>>>>>>>>>>>>> pairs are the infinite set of every encoding of Hx. I
>>>>>>>>>>>>>>>>>>> am going to stop
>>>>>>>>>>>>>>>>>>> right here and not proceed to another point until you
>>>>>>>>>>>>>>>>>>> fully understand
>>>>>>>>>>>>>>>>>>> and accept this point.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> OK then. You are saying that there are infinitely many
>>>>>>>>>>>>>>>>>> possible functions Hx, and that of these, infinitely
>>>>>>>>>>>>>>>>>> many do a correct simulation of the corresponding Px.
>>>>>>>>>>>>>>>>>> I am saying that while here are infinitely many
>>>>>>>>>>>>>>>>>> possible functions Hx, none of them do a correct
>>>>>>>>>>>>>>>>>> simulation of the corresponding Px.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> // An Infinite number of different halting computations
>>>>>>>>>>>>>>>>> can precede this:
>>>>>>>>>>>>>>>>> Simulate(x,y);
>>>>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> Hx(Px,Px);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You've completely failed to answer any of the questions!
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you accept that of the infinitely many possible
>>>>>>>>>>>>>>>> functions Hx, none of them do a correct simulation
>>>>>>>>>>>>>>> It is stipulated that I just provided such a function.
>>>>>>>>>>>>>>> Here it is again named differently:
>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> x86_emulate(x,y);
>>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Hx function that is computationally equivalent to the above:
>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> x(y);
>>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Fair enough. I ask you the questions a second time and you
>>>>>>>>>>>>>> just snip them again. You've provided one function which
>>>>>>>>>>>>>> simply calls another, unshown, function, so we can't have
>>>>>>>>>>>>>> a clue what it does. You've also said it is
>>>>>>>>>>>>>> "computationally equivalent" (whatever that means) to a
>>>>>>>>>>>>>> function which won't return a value. I can only assume
>>>>>>>>>>>>>> that you know full well that no functions provide a
>>>>>>>>>>>>>> correct result for Px and that you are simply trying to
>>>>>>>>>>>>>> bluff. There's no reason to further try to persuade you
>>>>>>>>>>>>>> that you're wrong, you apparently know it already.
>>>>>>>>>>>>> So you still don't understand that all simulating halt
>>>>>>>>>>>>> deciders PREDICT
>>>>>>>>>>>>> that their complete simulation of their input would never
>>>>>>>>>>>>> reach the
>>>>>>>>>>>>> final state of this simulated input without actually
>>>>>>>>>>>>> performing a
>>>>>>>>>>>>> complete simulation of this non-terminating input?
>>>>>>>>>>>>>
>>>>>>>>>>>>> *I have told you this dozens of times and you still don't
>>>>>>>>>>>>> get it*?
>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>> }
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>
>>>>>>>>>>>>> H0: Begin Simulation Execution Trace Stored at:211fac
>>>>>>>>>>>>> [00001102][00211f9c][00211fa0] 55 push ebp
>>>>>>>>>>>>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
>>>>>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>>>>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>>>>>>>>
>>>>>>>>>>>>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF
>>>>>>>>>>>>> _Infinite_Loop() YET STILL
>>>>>>>>>>>>> CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION WOULD
>>>>>>>>>>>>> NEVER HALT.
>>>>>>>>>>>>
>>>>>>>>>>>> I understand all of that. What YOU fail to understand is
>>>>>>>>>>>> that this cannot be applied to Px because Px does the
>>>>>>>>>>>> opposite of what Hx says it will.
>>>>>>>>>>> *PERHAPS THIS IS TOO DIFFICULT FOR YOU*
>>>>>>>>>>> There is no point in the correct execution trace of the correct
>>>>>>>>>>> simulation of any Px by Hx where any Px receives any return
>>>>>>>>>>> value from
>>>>>>>>>>> any Hx. This make it impossible for any correctly simulated
>>>>>>>>>>> Px to do the
>>>>>>>>>>> opposite of whatever Hx decides.
>>>>>>>>>>
>>>>>>>>>> The code of Px is as follows:
>>>>>>>>>>
>>>>>>>>>> void Px(ptr x)
>>>>>>>>>> {
>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>> if (Halt_Status)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> If Px is not receiving a value from Hx then it's not being
>>>>>>>>>> correctly simulated.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *The correct and complete simulation of the input to Hx(Px,Px)
>>>>>>>>> by Hx*
>>>>>>>>> (a) Hx(Px,Px) simulates Px(Px) that calls a simulated Hx(Px,Px)
>>>>>>>>> (b) that simulates Px(Px) that calls a simulated Hx(Px,Px)
>>>>>>>>> (c) that simulates Px(Px) that calls a simulated Hx(Px,Px)
>>>>>>>>> (d) that simulates Px(Px) that calls a simulated Hx(Px,Px)...
>>>>>>>>
>>>>>>>> Nope, not for the Hx that you claim models the H that gives an
>>>>>>>> answer.
>>>>>>>
>>>>>>> We get replies such as that when you glance at one or two words
>>>>>>> as your basis for forming a slip-shod fake rebuttal.
>>>>>>>
>>>>>>> When you actually incorporate all of the meaning of every single
>>>>>>> word your slip-shod fake rebuttal loses its basis.
>>>>>>>
>>>>>>> *The correct and complete*
>>>>>>> *The correct and complete*
>>>>>>> *The correct and complete*
>>>>>>> *The correct and complete*
>>>>>>>
>>>>>>> *simulation of the input to Hx(Px,Px) by Hx*
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Except that Hx doesn't do a complete simulation
>>>>>
>>>>> That does not matter. Because we know that the infinite set of
>>>>> every Hx of every Hx/Px pair that does a correct (partial or
>>>>> complete) simulation of Px never reaches the final state of Px even
>>>>> this program is a correct halt decider for that input:
>>>>>
>>>>> bool Answer_No()
>>>>> {
>>>>>    return false.
>>>>> }
>>>>>
>>>>>
>>>>
>>>> Nope, you are either lying or showing you are totally confused.
>>>>
>>>
>>> When the above function is answering the question:
>>> Does any Px correctly simulated by Hx reach the final state of Px?
>>> It is correct.
>>>
>>
>> Which is an irrelevent question unless you are talking about POOP
>> deciders.
>>
>>> When the above function is answering the question:
>>> Are the windows of office building usually made out of bananas?
>>> It is correct.
>>>
>>
>> But it isn't correct about does the input to H(P,P) represent Halting
>> behavior when H(P,P) returns 0.
>>
>
> A lie is an *intentional* falsehood.
>
> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
> Every Hx of every Hx/Px pair that returns 0 correctly reports that every
> correct (partial or complete) simulation of its input never reaches the
> final state of this correctly simulated input.
>
>

On 9/11/22 3:40 PM, olcott wrote:

> If an input to a simulator specifies recursive simulation then any
> simulator that does not implement recursive simulation is incorrect.

NO call to a decider "specifies" "recursive simulation".

If the decider CHOOSES to simulate, that is on it, and it is responsible
for the consequences of that decision.

Ultimately, it seems you have a moral problem that you do not understand
that a "program" is responsible to meet its stated requriements (input
to output mapping) and is responsible for any side effect that come out
of its choosen method to compute that mapping.

H can not "blame" the input for infinite recursion, because that a
specified result of the question made to the Halt Decider.

Yes, if P(x) called UTM(x,x) then P could be blamed for the infinite
recursion that comes from the computation P(P), as UTM is DEFINED to do
that simulation.

H(x) is NOT defined to do a "simulation of its input" but to decide on
what such a simulation would do, and do it in finite time. That is
different. If it does it by trying to actually simulate, then it is on H
to keep that operation finite, so P did NOT create an infinite recursion.

If your are changing the definition of H so that it DOES require it to
simulate, then your H now fails to be a Halt Decider, as Halt Deciders
are REQUIRED to always answer in finite time, and it can't do that if
it must simulate its input.

So, you arguement fails.

On 9/11/2022 2:54 PM, Mr Flibble wrote:
> On Sun, 11 Sep 2022 14:40:40 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 9/11/2022 2:23 PM, Mr Flibble wrote:
>>> On Sun, 11 Sep 2022 10:03:20 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 9/10/2022 7:56 PM, Mr Flibble wrote:
>>>>> On Sat, 10 Sep 2022 15:55:35 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 9/10/2022 3:29 PM, Mr Flibble wrote:
>>>>>>> On Sat, 10 Sep 2022 15:24:39 -0500
>>>>>>> olcott <none-ya@beez-wax.com> wrote:
>>>>>>>
>>>>>>>> On 9/10/2022 2:44 PM, Paul N wrote:
>>>>>>>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott
>>>>>>>>> wrote:
>>>>>>>>>> On 9/10/2022 2:06 PM, Paul N wrote:
>>>>>>>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1, olcott
>>>>>>>>>>> wrote:
>>>>>>>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
>>>>>>>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1,
>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1,
>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM
>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status =
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x); if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status) HERE:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goto HERE; return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does any complete and correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Px by Hx ever stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns zero
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then Px halts, and if Hx returns non-zero
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then Px does not halt. So Hx can never do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a complete and correct simulation of Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and return the right answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are discussing the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Just to clarify, we're talking about pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx and Px where the Px of the pair calls
>>>>>>>>>>>>>>>>>>>>>>>>>>> the Hx of the pair as in the code above,
>>>>>>>>>>>>>>>>>>>>>>>>>>> but we're not putting any restrictions on
>>>>>>>>>>>>>>>>>>>>>>>>>>> what Hx does?
>>>>>>>>>>>>>>>>>>>>>>>>>>>> An infinite subset of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> these do a complete and correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of their input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the pair
>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts whether the Px of the
>>>>>>>>>>>>>>>>>>>>>>>>>>> pair halts, then no, they ALL get it wrong,
>>>>>>>>>>>>>>>>>>>>>>>>>>> as shown above.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this subset would remain stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely recursive simulation such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px never reaches its final state and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation never stops, thus Hx never
>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns any value.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> This point is moot, there are no pairs in
>>>>>>>>>>>>>>>>>>>>>>>>>>> this subset.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into ancient
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Egyptian.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> and makes all the moves where Deep Blue
>>>>>>>>>>>>>>>>>>>>>>>>>>>> beat Garry Kasparov in the famous sixth
>>>>>>>>>>>>>>>>>>>>>>>>>>>> match.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) An infinite subset of the *remaining
>>>>>>>>>>>>>>>>>>>>>>>>>>>> subsets* ignores its input and returns each
>>>>>>>>>>>>>>>>>>>>>>>>>>>> element of the set of integers, thus one of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> them returns 1 and another returns 0, this
>>>>>>>>>>>>>>>>>>>>>>>>>>>> one is called the *wild guess halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider*
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> All of the wild guess deciders will be
>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. The one always guessing 0 will
>>>>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>> The one always guessing 1 will always be
>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong for Px, its Px will not halt. Follow
>>>>>>>>>>>>>>>>>>>>>>>>>>> the code of Px if you don't believe me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (4) One of these implements the algorithm
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of my simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When it is the job of the halt decider to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predict whether or not its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would halt even the *wild guess halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider* element of subset (3) is correct:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will not
>>>>>>>>>>>>>>>>>>>>>>>>>>> halt, but Px does halt. Try running it!
>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px by
>>>>>>>>>>>>>>>>>>>>>>>>>> Hx never halt therefore any damn thing that
>>>>>>>>>>>>>>>>>>>>>>>>>> says: "all correct and complete simulations
>>>>>>>>>>>>>>>>>>>>>>>>>> of Px by Hx never halt therefore" *IS
>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Firstly, I see that you have ignored almost
>>>>>>>>>>>>>>>>>>>>>>>>> all of what I wrote and are headed off in a
>>>>>>>>>>>>>>>>>>>>>>>>> different direction. I wonder why?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So you don't understand the above point that
>>>>>>>>>>>>>>>>>>>>>>>> applies to every program that return 0?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If you mean the four lines just above, no, I am
>>>>>>>>>>>>>>>>>>>>>>> not clear what they say. I'm not even sure you
>>>>>>>>>>>>>>>>>>>>>>> know what they say. I think you need some words
>>>>>>>>>>>>>>>>>>>>>>> after the second "therefore" to make them make
>>>>>>>>>>>>>>>>>>>>>>> sense.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>> The code for Px is fully specified. The code for
>>>>>>>>>>>>>>>>>>>>>> Hx is the infinite set of every C function that
>>>>>>>>>>>>>>>>>>>>>> takes a pair of ptr arguments. These arguments
>>>>>>>>>>>>>>>>>>>>>> can be ignored, summed together, multiplied
>>>>>>>>>>>>>>>>>>>>>> together, simulated, or anything else. One
>>>>>>>>>>>>>>>>>>>>>> element of Hx ignores its arguments, translates
>>>>>>>>>>>>>>>>>>>>>> the Lord's prayer into ancient Egyptian and
>>>>>>>>>>>>>>>>>>>>>> returns 56.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A subset of these C functions perform a correct
>>>>>>>>>>>>>>>>>>>>>> partial or complete simulation of their input. In
>>>>>>>>>>>>>>>>>>>>>> none of the elements of this set does Px ever
>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A subset of the original set return a value of 0,
>>>>>>>>>>>>>>>>>>>>>> which turns out to be the correct answer to the
>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Does there exist any element of the infinite set
>>>>>>>>>>>>>>>>>>>>>> of Hx/Px pairs such that Px correctly simulated
>>>>>>>>>>>>>>>>>>>>>> by Hx reaches the final state of Px?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> One element of the prior set correctly matches a
>>>>>>>>>>>>>>>>>>>>>> correct infinite behavior pattern, aborts the
>>>>>>>>>>>>>>>>>>>>>> simulation of its input on the basis and returns
>>>>>>>>>>>>>>>>>>>>>> 0.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You've quoted the code of Px above, are you really
>>>>>>>>>>>>>>>>>>>>> incapable of actually understanding it? Let's see:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that Hx(x,
>>>>>>>>>>>>>>>>>>>>> x) returns 0, so Halt_Status is set to zero
>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so this
>>>>>>>>>>>>>>>>>>>>>> "if" fails... HERE: goto HERE; // ... and so this
>>>>>>>>>>>>>>>>>>>>>> line is not executed ... return; // ... and we
>>>>>>>>>>>>>>>>>>>>>> get to here. }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So Px halts. There is no infinite behaviour
>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>> I have to update my last reply because I realized
>>>>>>>>>>>>>>>>>>>> that it was not accurate. I really only want an
>>>>>>>>>>>>>>>>>>>> honest dialogue and I incorrectly said that you
>>>>>>>>>>>>>>>>>>>> made a mistake that you did not make.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thank you for this. Yes, I was saying that if Hx(Px,
>>>>>>>>>>>>>>>>>>> Px) returns 0 then Px halts.
>>>>>>>>>>>>>>>>>>>> A simulating halt decider (SHD) only reports on the
>>>>>>>>>>>>>>>>>>>> behavior of what its complete and correct
>>>>>>>>>>>>>>>>>>>> simulation of its input would be, it never reports
>>>>>>>>>>>>>>>>>>>> on the actual behavior of what its partial
>>>>>>>>>>>>>>>>>>>> simulation is.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If a SHD reported on whether or not its input
>>>>>>>>>>>>>>>>>>>> stopped running then in those cases where the
>>>>>>>>>>>>>>>>>>>> simulated input stopped on its own and those cases
>>>>>>>>>>>>>>>>>>>> where the simulation was aborted the simulated
>>>>>>>>>>>>>>>>>>>> input stopped running. This derives a correct halt
>>>>>>>>>>>>>>>>>>>> decider with no discernment every input is
>>>>>>>>>>>>>>>>>>>> reported to stop running.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> To allow a SHD to have discernment it answers a
>>>>>>>>>>>>>>>>>>>> different question: Does any correct simulation of
>>>>>>>>>>>>>>>>>>>> its input reach the final state of this input?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The snag is that Hx must always give the wrong
>>>>>>>>>>>>>>>>>>> answer for Px,
>>>>>>>>>>>>>>>>>> That is not true. Of the infinite set of Hx that
>>>>>>>>>>>>>>>>>> correctly simulate Px none ever reach the final state
>>>>>>>>>>>>>>>>>> of Px.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I assume when you say "Hx that correctly simulate Px"
>>>>>>>>>>>>>>>>> you're not just talking about what Hx does internally,
>>>>>>>>>>>>>>>>> you are also saying that Hx returns the correct answer
>>>>>>>>>>>>>>>>> in a finite time. (If this is not what you mean then
>>>>>>>>>>>>>>>>> please spell out what you do mean more clearly.)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> As I've said before, there is not an infinite set of
>>>>>>>>>>>>>>>>> Hx that correctly simulate Px. EVERY Hx gets its
>>>>>>>>>>>>>>>>> corresponding Px wrong.
>>>>>>>>>>>>>>>>>> Every simulating halt decider must only predict the
>>>>>>>>>>>>>>>>>> behavior of what its correct and complete simulation
>>>>>>>>>>>>>>>>>> of its input would be and the must not report on the
>>>>>>>>>>>>>>>>>> actual behavior of its partial simulation. void
>>>>>>>>>>>>>>>>>> Infinite_Loop() {
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>> When H0 reports that its correct and complete
>>>>>>>>>>>>>>>>>> simulation of its input Infinite_Loop() would never
>>>>>>>>>>>>>>>>>> reach the final state of this simulated input it has
>>>>>>>>>>>>>>>>>> a sound basis.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes, there's no problem with this function and no
>>>>>>>>>>>>>>>>> reason why Hx need get it wrong. You've said that you
>>>>>>>>>>>>>>>>> have written an Hx which correctly handles this case
>>>>>>>>>>>>>>>>> and I have no reason to doubt this.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The problem with Px is that it necessarily does the
>>>>>>>>>>>>>>>>> opposite of what Hx predicts it will.
>>>>>>>>>>>>>>>> You must have not been paying hardly and attention at
>>>>>>>>>>>>>>>> all.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *The correct and complete simulation of the input to
>>>>>>>>>>>>>>>> Hx(P,P) by Hx* (a) Hx(P,P) simulates P(P) that calls a
>>>>>>>>>>>>>>>> simulated Hx(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>> simulated Hx(P,P) (c) that simulates P(P) that calls a
>>>>>>>>>>>>>>>> simulated Hx(P,P) (d) that simulates P(P) that calls a
>>>>>>>>>>>>>>>> simulated Hx(P,P)...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nonsense. You've told us many times that Hx does not
>>>>>>>>>>>>>>> behave like this. So it is not a correct simulation to
>>>>>>>>>>>>>>> pretend that it does.
>>>>>>>>>>>>>> Hx is not the same as H. As I have told you several times
>>>>>>>>>>>>>> now, the Hx/Px pairs are the infinite set of every
>>>>>>>>>>>>>> encoding of Hx. I am going to stop right here and not
>>>>>>>>>>>>>> proceed to another point until you fully understand and
>>>>>>>>>>>>>> accept this point.
>>>>>>>>>>>>>
>>>>>>>>>>>>> OK then. You are saying that there are infinitely many
>>>>>>>>>>>>> possible functions Hx, and that of these, infinitely many
>>>>>>>>>>>>> do a correct simulation of the corresponding Px. I am
>>>>>>>>>>>>> saying that while here are infinitely many possible
>>>>>>>>>>>>> functions Hx, none of them do a correct simulation of the
>>>>>>>>>>>>> corresponding Px.
>>>>>>>>>>>>
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>> // An Infinite number of different halting computations can
>>>>>>>>>>>> precede this: Simulate(x,y);
>>>>>>>>>>>> return 1;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Hx(Px,Px);
>>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> You've completely failed to answer any of the questions!
>>>>>>>>>>>
>>>>>>>>>>> If you accept that of the infinitely many possible functions
>>>>>>>>>>> Hx, none of them do a correct simulation
>>>>>>>>>> It is stipulated that I just provided such a function.
>>>>>>>>>> Here it is again named differently:
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>> x86_emulate(x,y);
>>>>>>>>>> return 1;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Hx function that is computationally equivalent to the above:
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>> x(y);
>>>>>>>>>> return 1;
>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Fair enough. I ask you the questions a second time and you
>>>>>>>>> just snip them again. You've provided one function which
>>>>>>>>> simply calls another, unshown, function, so we can't have a
>>>>>>>>> clue what it does. You've also said it is "computationally
>>>>>>>>> equivalent" (whatever that means) to a function which won't
>>>>>>>>> return a value. I can only assume that you know full well
>>>>>>>>> that no functions provide a correct result for Px and that
>>>>>>>>> you are simply trying to bluff. There's no reason to further
>>>>>>>>> try to persuade you that you're wrong, you apparently know it
>>>>>>>>> already.
>>>>>>>>
>>>>>>>> So you still don't understand that all simulating halt deciders
>>>>>>>> PREDICT that their complete simulation of their input would
>>>>>>>> never reach the final state of this simulated input without
>>>>>>>> actually performing a complete simulation of this
>>>>>>>> non-terminating input?
>>>>>>>>
>>>>>>>> *I have told you this dozens of times and you still don't get
>>>>>>>> it*?
>>>>>>>>
>>>>>>>> void Infinite_Loop()
>>>>>>>> {
>>>>>>>> HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>> }
>>>>>>>>
>>>>>>>> _Infinite_Loop()
>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>> [00001108](01) c3 ret
>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>
>>>>>>>> H0: Begin Simulation Execution Trace Stored at:211fac
>>>>>>>> [00001102][00211f9c][00211fa0] 55 push ebp
>>>>>>>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>>>
>>>>>>>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF _Infinite_Loop()
>>>>>>>> YET STILL CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION
>>>>>>>> WOULD NEVER HALT.
>>>>>>>
>>>>>>> Detecting non-halting is different to aborting a simulation
>>>>>>> because the decider is incorrectly designed using recursion.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> *It* is easy to verify that HH(PP,PP) is correctly designed to do
>>>>>> recursive simulation. This was the hardest part of the entire
>>>>>> design. https://liarparadox.org/2022_09_07.zip
>>>>>>
>>>>>> Each emulation requires its own process context including its own
>>>>>> stack space.
>>>>>
>>>>> Recursive simulation is the wrong approach as a halting decider is
>>>>> supposed to always return a result to its caller. The Flibble
>>>>> Signaling Halt Decider (tm) is a simulating halt decider that does
>>>>> not rely on recursion.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> If an input specifies infinitely recursive simulation then its
>>>> correct simulation requires this.
>>>
>>> That isn't what I said. Again: a decider does not have to be
>>> recursive in order to simulate something that is recursive.
>>
>> If an input to a simulator specifies recursive simulation then any
>> simulator that does not implement recursive simulation is incorrect.
>
> That isn't what I said. Again: a decider does not have to be recursive
> in order to simulate something that is recursive.
>
> /Flibble
>

On 9/11/2022 5:12 PM, Richard Damon wrote:
> On 9/11/22 3:38 PM, olcott wrote:
>> On 9/11/2022 2:06 PM, Richard Damon wrote:
>>> On 9/11/22 2:52 PM, olcott wrote:
>>>> On 9/11/2022 1:38 PM, Richard Damon wrote:
>>>>> On 9/11/22 2:13 PM, olcott wrote:
>>>>>> On 9/11/2022 12:29 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/11/22 1:20 PM, olcott wrote:
>>>>>>>> On 9/11/2022 12:00 PM, Richard Damon wrote:
>>>>>>>>> On 9/11/22 12:44 PM, olcott wrote:
>>>>>>>>>> On 9/11/2022 11:28 AM, Paul N wrote:
>>>>>>>>>>> On Sunday, September 11, 2022 at 4:48:22 PM UTC+1, olcott wrote:
>>>>>>>>>>>> On 9/11/2022 10:23 AM, Paul N wrote:
>>>>>>>>>>>>> On Saturday, September 10, 2022 at 9:24:43 PM UTC+1, olcott
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> On 9/10/2022 2:44 PM, Paul N wrote:
>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1,
>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>> On 9/10/2022 2:06 PM, Paul N wrote:
>>>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM
>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11:34:08 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:50:20 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:09:44 AM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt_Status =
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does any complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx ever stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> zero then Px halts, and if Hx returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-zero then Px does not halt. So Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can never do a complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px and return the right
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are discussing the infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just to clarify, we're talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs Hx and Px where the Px of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pair calls the Hx of the pair as in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code above, but we're not putting any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> restrictions on what Hx does?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> An infinite subset of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these do a complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of their input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pair correctly predicts whether the Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the pair halts, then no, they ALL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> get it wrong, as shown above.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all of this subset would remain
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stuck in infinitely recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation such that Px never reaches its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state and the simulation never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stops, thus Hx never returns any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This point is moot, there are no pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in this subset.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ancient Egyptian.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and makes all the moves where
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deep Blue beat Garry Kasparov in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> famous sixth match.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) An infinite subset of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *remaining subsets* ignores its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns each element of the set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> integers, thus one of them returns 1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and another returns 0, this one is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called the *wild guess halt decider*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of the wild guess deciders will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. The one always guessing 0 will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt. The one always guessing 1 will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt. Follow the code of Px if you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't believe me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (4) One of these implements the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm of my simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When it is the job of the halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to correctly predict whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not its correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *wild guess halt decider* element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset (3) is correct:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt, but Px does halt. Try running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx never halt therefore
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any damn thing that says:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "all correct and complete simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx never halt therefore"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Firstly, I see that you have ignored
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> almost all of what I wrote and are headed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> off in a different direction. I wonder why?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you don't understand the above point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that applies to every program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that return 0?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you mean the four lines just above, no,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am not clear what they say. I'm not even
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sure you know what they say. I think you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> need some words after the second
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "therefore" to make them make sense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The code for Px is fully specified. The code
>>>>>>>>>>>>>>>>>>>>>>>>>>>> for Hx is the infinite set
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of every C function that takes a pair of ptr
>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments. These arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>> can be ignored, summed together, multiplied
>>>>>>>>>>>>>>>>>>>>>>>>>>>> together, simulated, or
>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything else. One element of Hx ignores its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments, translates the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Lord's prayer into ancient Egyptian and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 56.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of these C functions perform a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct partial or complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of their input. In none of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of this set does Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of the original set return a value
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of 0, which turns out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer to the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does there exist any element of the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Px correctly simulated by Hx reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the final state of Px?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> One element of the prior set correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern, aborts the simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input on the basis and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You've quoted the code of Px above, are you
>>>>>>>>>>>>>>>>>>>>>>>>>>> really incapable of actually understanding
>>>>>>>>>>>>>>>>>>>>>>>>>>> it? Let's see:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that
>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x) returns 0, so Halt_Status is set to
>>>>>>>>>>>>>>>>>>>>>>>>>>> zero
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this "if" fails...
>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE; // ... and so this line is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> not executed ...
>>>>>>>>>>>>>>>>>>>>>>>>>>>> return; // ... and we get to here.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So Px halts. There is no infinite behaviour
>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>> I have to update my last reply because I
>>>>>>>>>>>>>>>>>>>>>>>>>> realized that it was not
>>>>>>>>>>>>>>>>>>>>>>>>>> accurate. I really only want an honest
>>>>>>>>>>>>>>>>>>>>>>>>>> dialogue and I incorrectly said
>>>>>>>>>>>>>>>>>>>>>>>>>> that you made a mistake that you did not make.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Thank you for this. Yes, I was saying that if
>>>>>>>>>>>>>>>>>>>>>>>>> Hx(Px, Px) returns 0 then Px halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider (SHD) only reports
>>>>>>>>>>>>>>>>>>>>>>>>>> on the behavior of what its
>>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>> would be, it never reports
>>>>>>>>>>>>>>>>>>>>>>>>>> on the actual behavior of what its partial
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation is.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If a SHD reported on whether or not its input
>>>>>>>>>>>>>>>>>>>>>>>>>> stopped running then in
>>>>>>>>>>>>>>>>>>>>>>>>>> those cases where the simulated input stopped
>>>>>>>>>>>>>>>>>>>>>>>>>> on its own and those cases
>>>>>>>>>>>>>>>>>>>>>>>>>> where the simulation was aborted the simulated
>>>>>>>>>>>>>>>>>>>>>>>>>> input stopped running.
>>>>>>>>>>>>>>>>>>>>>>>>>> This derives a correct halt decider with no
>>>>>>>>>>>>>>>>>>>>>>>>>> discernment every input is
>>>>>>>>>>>>>>>>>>>>>>>>>> reported to stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> To allow a SHD to have discernment it answers
>>>>>>>>>>>>>>>>>>>>>>>>>> a different question:
>>>>>>>>>>>>>>>>>>>>>>>>>> Does any correct simulation of its input reach
>>>>>>>>>>>>>>>>>>>>>>>>>> the final state of this
>>>>>>>>>>>>>>>>>>>>>>>>>> input?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The snag is that Hx must always give the wrong
>>>>>>>>>>>>>>>>>>>>>>>>> answer for Px,
>>>>>>>>>>>>>>>>>>>>>>>> That is not true. Of the infinite set of Hx that
>>>>>>>>>>>>>>>>>>>>>>>> correctly simulate Px
>>>>>>>>>>>>>>>>>>>>>>>> none ever reach the final state of Px.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I assume when you say "Hx that correctly simulate
>>>>>>>>>>>>>>>>>>>>>>> Px" you're not just talking about what Hx does
>>>>>>>>>>>>>>>>>>>>>>> internally, you are also saying that Hx returns
>>>>>>>>>>>>>>>>>>>>>>> the correct answer in a finite time. (If this is
>>>>>>>>>>>>>>>>>>>>>>> not what you mean then please spell out what you
>>>>>>>>>>>>>>>>>>>>>>> do mean more clearly.)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> As I've said before, there is not an infinite set
>>>>>>>>>>>>>>>>>>>>>>> of Hx that correctly simulate Px. EVERY Hx gets
>>>>>>>>>>>>>>>>>>>>>>> its corresponding Px wrong.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Every simulating halt decider must only predict
>>>>>>>>>>>>>>>>>>>>>>>> the behavior of what its
>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>> would be and the must not
>>>>>>>>>>>>>>>>>>>>>>>> report on the actual behavior of its partial
>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>> When H0 reports that its correct and complete
>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() would never reach the final
>>>>>>>>>>>>>>>>>>>>>>>> state of this simulated
>>>>>>>>>>>>>>>>>>>>>>>> input it has a sound basis.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Yes, there's no problem with this function and no
>>>>>>>>>>>>>>>>>>>>>>> reason why Hx need get it wrong. You've said that
>>>>>>>>>>>>>>>>>>>>>>> you have written an Hx which correctly handles
>>>>>>>>>>>>>>>>>>>>>>> this case and I have no reason to doubt this.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The problem with Px is that it necessarily does
>>>>>>>>>>>>>>>>>>>>>>> the opposite of what Hx predicts it will.
>>>>>>>>>>>>>>>>>>>>>> You must have not been paying hardly and attention
>>>>>>>>>>>>>>>>>>>>>> at all.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>>> to Hx(P,P) by Hx*
>>>>>>>>>>>>>>>>>>>>>> (a) Hx(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>> Hx(P,P)
>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>> Hx(P,P)
>>>>>>>>>>>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>> Hx(P,P)
>>>>>>>>>>>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>> Hx(P,P)...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nonsense. You've told us many times that Hx does
>>>>>>>>>>>>>>>>>>>>> not behave like this. So it is not a correct
>>>>>>>>>>>>>>>>>>>>> simulation to pretend that it does.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Hx is not the same as H. As I have told you several
>>>>>>>>>>>>>>>>>>>> times now, the Hx/Px
>>>>>>>>>>>>>>>>>>>> pairs are the infinite set of every encoding of Hx.
>>>>>>>>>>>>>>>>>>>> I am going to stop
>>>>>>>>>>>>>>>>>>>> right here and not proceed to another point until
>>>>>>>>>>>>>>>>>>>> you fully understand
>>>>>>>>>>>>>>>>>>>> and accept this point.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> OK then. You are saying that there are infinitely
>>>>>>>>>>>>>>>>>>> many possible functions Hx, and that of these,
>>>>>>>>>>>>>>>>>>> infinitely many do a correct simulation of the
>>>>>>>>>>>>>>>>>>> corresponding Px. I am saying that while here are
>>>>>>>>>>>>>>>>>>> infinitely many possible functions Hx, none of them
>>>>>>>>>>>>>>>>>>> do a correct simulation of the corresponding Px.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> // An Infinite number of different halting
>>>>>>>>>>>>>>>>>> computations can precede this:
>>>>>>>>>>>>>>>>>> Simulate(x,y);
>>>>>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Hx(Px,Px);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You've completely failed to answer any of the questions!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If you accept that of the infinitely many possible
>>>>>>>>>>>>>>>>> functions Hx, none of them do a correct simulation
>>>>>>>>>>>>>>>> It is stipulated that I just provided such a function.
>>>>>>>>>>>>>>>> Here it is again named differently:
>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> x86_emulate(x,y);
>>>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Hx function that is computationally equivalent to the
>>>>>>>>>>>>>>>> above:
>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> x(y);
>>>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Fair enough. I ask you the questions a second time and
>>>>>>>>>>>>>>> you just snip them again. You've provided one function
>>>>>>>>>>>>>>> which simply calls another, unshown, function, so we
>>>>>>>>>>>>>>> can't have a clue what it does. You've also said it is
>>>>>>>>>>>>>>> "computationally equivalent" (whatever that means) to a
>>>>>>>>>>>>>>> function which won't return a value. I can only assume
>>>>>>>>>>>>>>> that you know full well that no functions provide a
>>>>>>>>>>>>>>> correct result for Px and that you are simply trying to
>>>>>>>>>>>>>>> bluff. There's no reason to further try to persuade you
>>>>>>>>>>>>>>> that you're wrong, you apparently know it already.
>>>>>>>>>>>>>> So you still don't understand that all simulating halt
>>>>>>>>>>>>>> deciders PREDICT
>>>>>>>>>>>>>> that their complete simulation of their input would never
>>>>>>>>>>>>>> reach the
>>>>>>>>>>>>>> final state of this simulated input without actually
>>>>>>>>>>>>>> performing a
>>>>>>>>>>>>>> complete simulation of this non-terminating input?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *I have told you this dozens of times and you still don't
>>>>>>>>>>>>>> get it*?
>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H0: Begin Simulation Execution Trace Stored at:211fac
>>>>>>>>>>>>>> [00001102][00211f9c][00211fa0] 55 push ebp
>>>>>>>>>>>>>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>>>>>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF
>>>>>>>>>>>>>> _Infinite_Loop() YET STILL
>>>>>>>>>>>>>> CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION WOULD
>>>>>>>>>>>>>> NEVER HALT.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I understand all of that. What YOU fail to understand is
>>>>>>>>>>>>> that this cannot be applied to Px because Px does the
>>>>>>>>>>>>> opposite of what Hx says it will.
>>>>>>>>>>>> *PERHAPS THIS IS TOO DIFFICULT FOR YOU*
>>>>>>>>>>>> There is no point in the correct execution trace of the correct
>>>>>>>>>>>> simulation of any Px by Hx where any Px receives any return
>>>>>>>>>>>> value from
>>>>>>>>>>>> any Hx. This make it impossible for any correctly simulated
>>>>>>>>>>>> Px to do the
>>>>>>>>>>>> opposite of whatever Hx decides.
>>>>>>>>>>>
>>>>>>>>>>> The code of Px is as follows:
>>>>>>>>>>>
>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>> return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> If Px is not receiving a value from Hx then it's not being
>>>>>>>>>>> correctly simulated.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *The correct and complete simulation of the input to Hx(Px,Px)
>>>>>>>>>> by Hx*
>>>>>>>>>> (a) Hx(Px,Px) simulates Px(Px) that calls a simulated Hx(Px,Px)
>>>>>>>>>> (b) that simulates Px(Px) that calls a simulated Hx(Px,Px)
>>>>>>>>>> (c) that simulates Px(Px) that calls a simulated Hx(Px,Px)
>>>>>>>>>> (d) that simulates Px(Px) that calls a simulated Hx(Px,Px)...
>>>>>>>>>
>>>>>>>>> Nope, not for the Hx that you claim models the H that gives an
>>>>>>>>> answer.
>>>>>>>>
>>>>>>>> We get replies such as that when you glance at one or two words
>>>>>>>> as your basis for forming a slip-shod fake rebuttal.
>>>>>>>>
>>>>>>>> When you actually incorporate all of the meaning of every single
>>>>>>>> word your slip-shod fake rebuttal loses its basis.
>>>>>>>>
>>>>>>>> *The correct and complete*
>>>>>>>> *The correct and complete*
>>>>>>>> *The correct and complete*
>>>>>>>> *The correct and complete*
>>>>>>>>
>>>>>>>> *simulation of the input to Hx(Px,Px) by Hx*
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Except that Hx doesn't do a complete simulation
>>>>>>
>>>>>> That does not matter. Because we know that the infinite set of
>>>>>> every Hx of every Hx/Px pair that does a correct (partial or
>>>>>> complete) simulation of Px never reaches the final state of Px
>>>>>> even this program is a correct halt decider for that input:
>>>>>>
>>>>>> bool Answer_No()
>>>>>> {
>>>>>>    return false.
>>>>>> }
>>>>>>
>>>>>>
>>>>>
>>>>> Nope, you are either lying or showing you are totally confused.
>>>>>
>>>>
>>>> When the above function is answering the question:
>>>> Does any Px correctly simulated by Hx reach the final state of Px?
>>>> It is correct.
>>>>
>>>
>>> Which is an irrelevent question unless you are talking about POOP
>>> deciders.
>>>
>>>> When the above function is answering the question:
>>>> Are the windows of office building usually made out of bananas?
>>>> It is correct.
>>>>
>>>
>>> But it isn't correct about does the input to H(P,P) represent Halting
>>> behavior when H(P,P) returns 0.
>>>
>>
>> A lie is an *intentional* falsehood.
>>
>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>> Every Hx of every Hx/Px pair that returns 0 correctly reports that
>> every correct (partial or complete) simulation of its input never
>> reaches the final state of this correctly simulated input.
>>
>>
>
> Nope, every Hx that returns 0 is INCORRECT about the COMPLETE simulaiton
> of its input.

On Mon, 12 Sep 2022 12:45:13 -0500
olcott <none-ya@beez-wax.com> wrote:

> On 9/11/2022 2:54 PM, Mr Flibble wrote:
> > On Sun, 11 Sep 2022 14:40:40 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 9/11/2022 2:23 PM, Mr Flibble wrote:
> >>> On Sun, 11 Sep 2022 10:03:20 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 9/10/2022 7:56 PM, Mr Flibble wrote:
> >>>>> On Sat, 10 Sep 2022 15:55:35 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 9/10/2022 3:29 PM, Mr Flibble wrote:
> >>>>>>> On Sat, 10 Sep 2022 15:24:39 -0500
> >>>>>>> olcott <none-ya@beez-wax.com> wrote:
> >>>>>>>
> >>>>>>>> On 9/10/2022 2:44 PM, Paul N wrote:
> >>>>>>>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott
> >>>>>>>>> wrote:
> >>>>>>>>>> On 9/10/2022 2:06 PM, Paul N wrote:
> >>>>>>>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1,
> >>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
> >>>>>>>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1,
> >>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
> >>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1,
> >>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM
> >>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM
> >>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08
> >>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20
> >>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:09:44 AM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56 PM,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status =
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x); if
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return; }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = ", Hx(Px, Px));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does any complete and correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx ever stop
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> zero then Px halts, and if Hx returns
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-zero then Px does not halt. So Hx
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> can never do a complete and correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px and return the right
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> We are discussing the infinite set of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Just to clarify, we're talking about pairs
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Hx and Px where the Px of the pair calls
> >>>>>>>>>>>>>>>>>>>>>>>>>>> the Hx of the pair as in the code above,
> >>>>>>>>>>>>>>>>>>>>>>>>>>> but we're not putting any restrictions on
> >>>>>>>>>>>>>>>>>>>>>>>>>>> what Hx does?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> An infinite subset of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> these do a complete and correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of their input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>> pair correctly predicts whether the Px of
> >>>>>>>>>>>>>>>>>>>>>>>>>>> the pair halts, then no, they ALL get it
> >>>>>>>>>>>>>>>>>>>>>>>>>>> wrong, as shown above.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> of this subset would remain stuck in
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely recursive simulation such that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Px never reaches its final state and the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation never stops, thus Hx never
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> returns any value.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> This point is moot, there are no pairs in
> >>>>>>>>>>>>>>>>>>>>>>>>>>> this subset.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into ancient
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Egyptian.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> input and makes all the moves where Deep
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Blue beat Garry Kasparov in the famous
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> sixth match.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) An infinite subset of the *remaining
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> subsets* ignores its input and returns
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> each element of the set of integers,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> thus one of them returns 1 and another
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, this one is called the *wild
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> guess halt decider*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> All of the wild guess deciders will be
> >>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. The one always guessing 0 will
> >>>>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will halt.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> The one always guessing 1 will always be
> >>>>>>>>>>>>>>>>>>>>>>>>>>> wrong for Px, its Px will not halt. Follow
> >>>>>>>>>>>>>>>>>>>>>>>>>>> the code of Px if you don't believe me.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (4) One of these implements the algorithm
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> of my simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> When it is the job of the halt decider to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predict whether or not its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> input would halt even the *wild guess
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider* element of subset (3) is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will not
> >>>>>>>>>>>>>>>>>>>>>>>>>>> halt, but Px does halt. Try running it!
> >>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px
> >>>>>>>>>>>>>>>>>>>>>>>>>> by Hx never halt therefore any damn thing
> >>>>>>>>>>>>>>>>>>>>>>>>>> that says: "all correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px by Hx never halt
> >>>>>>>>>>>>>>>>>>>>>>>>>> therefore" *IS NECESSARILY CORRECT*
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Firstly, I see that you have ignored almost
> >>>>>>>>>>>>>>>>>>>>>>>>> all of what I wrote and are headed off in a
> >>>>>>>>>>>>>>>>>>>>>>>>> different direction. I wonder why?
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> So you don't understand the above point that
> >>>>>>>>>>>>>>>>>>>>>>>> applies to every program that return 0?
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> If you mean the four lines just above, no, I
> >>>>>>>>>>>>>>>>>>>>>>> am not clear what they say. I'm not even sure
> >>>>>>>>>>>>>>>>>>>>>>> you know what they say. I think you need some
> >>>>>>>>>>>>>>>>>>>>>>> words after the second "therefore" to make
> >>>>>>>>>>>>>>>>>>>>>>> them make sense.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>> The code for Px is fully specified. The code
> >>>>>>>>>>>>>>>>>>>>>> for Hx is the infinite set of every C function
> >>>>>>>>>>>>>>>>>>>>>> that takes a pair of ptr arguments. These
> >>>>>>>>>>>>>>>>>>>>>> arguments can be ignored, summed together,
> >>>>>>>>>>>>>>>>>>>>>> multiplied together, simulated, or anything
> >>>>>>>>>>>>>>>>>>>>>> else. One element of Hx ignores its arguments,
> >>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into ancient
> >>>>>>>>>>>>>>>>>>>>>> Egyptian and returns 56.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> A subset of these C functions perform a correct
> >>>>>>>>>>>>>>>>>>>>>> partial or complete simulation of their input.
> >>>>>>>>>>>>>>>>>>>>>> In none of the elements of this set does Px
> >>>>>>>>>>>>>>>>>>>>>> ever reach its final state.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> A subset of the original set return a value of
> >>>>>>>>>>>>>>>>>>>>>> 0, which turns out to be the correct answer to
> >>>>>>>>>>>>>>>>>>>>>> the question:
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Does there exist any element of the infinite
> >>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such that Px correctly
> >>>>>>>>>>>>>>>>>>>>>> simulated by Hx reaches the final state of Px?
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> One element of the prior set correctly matches
> >>>>>>>>>>>>>>>>>>>>>> a correct infinite behavior pattern, aborts the
> >>>>>>>>>>>>>>>>>>>>>> simulation of its input on the basis and
> >>>>>>>>>>>>>>>>>>>>>> returns 0.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> You've quoted the code of Px above, are you
> >>>>>>>>>>>>>>>>>>>>> really incapable of actually understanding it?
> >>>>>>>>>>>>>>>>>>>>> Let's see:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that
> >>>>>>>>>>>>>>>>>>>>> Hx(x, x) returns 0, so Halt_Status is set to
> >>>>>>>>>>>>>>>>>>>>> zero
> >>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so
> >>>>>>>>>>>>>>>>>>>>>> this "if" fails... HERE: goto HERE; // ... and
> >>>>>>>>>>>>>>>>>>>>>> so this line is not executed ... return; //
> >>>>>>>>>>>>>>>>>>>>>> ... and we get to here. }
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> So Px halts. There is no infinite behaviour
> >>>>>>>>>>>>>>>>>>>>> pattern.
> >>>>>>>>>>>>>>>>>>>> I have to update my last reply because I realized
> >>>>>>>>>>>>>>>>>>>> that it was not accurate. I really only want an
> >>>>>>>>>>>>>>>>>>>> honest dialogue and I incorrectly said that you
> >>>>>>>>>>>>>>>>>>>> made a mistake that you did not make.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Thank you for this. Yes, I was saying that if
> >>>>>>>>>>>>>>>>>>> Hx(Px, Px) returns 0 then Px halts.
> >>>>>>>>>>>>>>>>>>>> A simulating halt decider (SHD) only reports on
> >>>>>>>>>>>>>>>>>>>> the behavior of what its complete and correct
> >>>>>>>>>>>>>>>>>>>> simulation of its input would be, it never
> >>>>>>>>>>>>>>>>>>>> reports on the actual behavior of what its
> >>>>>>>>>>>>>>>>>>>> partial simulation is.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> If a SHD reported on whether or not its input
> >>>>>>>>>>>>>>>>>>>> stopped running then in those cases where the
> >>>>>>>>>>>>>>>>>>>> simulated input stopped on its own and those
> >>>>>>>>>>>>>>>>>>>> cases where the simulation was aborted the
> >>>>>>>>>>>>>>>>>>>> simulated input stopped running. This derives a
> >>>>>>>>>>>>>>>>>>>> correct halt decider with no discernment every
> >>>>>>>>>>>>>>>>>>>> input is reported to stop running.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> To allow a SHD to have discernment it answers a
> >>>>>>>>>>>>>>>>>>>> different question: Does any correct simulation
> >>>>>>>>>>>>>>>>>>>> of its input reach the final state of this
> >>>>>>>>>>>>>>>>>>>> input?
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The snag is that Hx must always give the wrong
> >>>>>>>>>>>>>>>>>>> answer for Px,
> >>>>>>>>>>>>>>>>>> That is not true. Of the infinite set of Hx that
> >>>>>>>>>>>>>>>>>> correctly simulate Px none ever reach the final
> >>>>>>>>>>>>>>>>>> state of Px.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> I assume when you say "Hx that correctly simulate
> >>>>>>>>>>>>>>>>> Px" you're not just talking about what Hx does
> >>>>>>>>>>>>>>>>> internally, you are also saying that Hx returns the
> >>>>>>>>>>>>>>>>> correct answer in a finite time. (If this is not
> >>>>>>>>>>>>>>>>> what you mean then please spell out what you do
> >>>>>>>>>>>>>>>>> mean more clearly.)
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> As I've said before, there is not an infinite set of
> >>>>>>>>>>>>>>>>> Hx that correctly simulate Px. EVERY Hx gets its
> >>>>>>>>>>>>>>>>> corresponding Px wrong.
> >>>>>>>>>>>>>>>>>> Every simulating halt decider must only predict the
> >>>>>>>>>>>>>>>>>> behavior of what its correct and complete
> >>>>>>>>>>>>>>>>>> simulation of its input would be and the must not
> >>>>>>>>>>>>>>>>>> report on the actual behavior of its partial
> >>>>>>>>>>>>>>>>>> simulation. void Infinite_Loop() {
> >>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>> When H0 reports that its correct and complete
> >>>>>>>>>>>>>>>>>> simulation of its input Infinite_Loop() would never
> >>>>>>>>>>>>>>>>>> reach the final state of this simulated input it
> >>>>>>>>>>>>>>>>>> has a sound basis.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Yes, there's no problem with this function and no
> >>>>>>>>>>>>>>>>> reason why Hx need get it wrong. You've said that
> >>>>>>>>>>>>>>>>> you have written an Hx which correctly handles this
> >>>>>>>>>>>>>>>>> case and I have no reason to doubt this.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The problem with Px is that it necessarily does the
> >>>>>>>>>>>>>>>>> opposite of what Hx predicts it will.
> >>>>>>>>>>>>>>>> You must have not been paying hardly and attention at
> >>>>>>>>>>>>>>>> all.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *The correct and complete simulation of the input to
> >>>>>>>>>>>>>>>> Hx(P,P) by Hx* (a) Hx(P,P) simulates P(P) that calls
> >>>>>>>>>>>>>>>> a simulated Hx(P,P) (b) that simulates P(P) that
> >>>>>>>>>>>>>>>> calls a simulated Hx(P,P) (c) that simulates P(P)
> >>>>>>>>>>>>>>>> that calls a simulated Hx(P,P) (d) that simulates
> >>>>>>>>>>>>>>>> P(P) that calls a simulated Hx(P,P)...
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Nonsense. You've told us many times that Hx does not
> >>>>>>>>>>>>>>> behave like this. So it is not a correct simulation to
> >>>>>>>>>>>>>>> pretend that it does.
> >>>>>>>>>>>>>> Hx is not the same as H. As I have told you several
> >>>>>>>>>>>>>> times now, the Hx/Px pairs are the infinite set of
> >>>>>>>>>>>>>> every encoding of Hx. I am going to stop right here
> >>>>>>>>>>>>>> and not proceed to another point until you fully
> >>>>>>>>>>>>>> understand and accept this point.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> OK then. You are saying that there are infinitely many
> >>>>>>>>>>>>> possible functions Hx, and that of these, infinitely
> >>>>>>>>>>>>> many do a correct simulation of the corresponding Px. I
> >>>>>>>>>>>>> am saying that while here are infinitely many possible
> >>>>>>>>>>>>> functions Hx, none of them do a correct simulation of
> >>>>>>>>>>>>> the corresponding Px.
> >>>>>>>>>>>>
> >>>>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> // An Infinite number of different halting computations
> >>>>>>>>>>>> can precede this: Simulate(x,y);
> >>>>>>>>>>>> return 1;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Hx(Px,Px);
> >>>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> You've completely failed to answer any of the questions!
> >>>>>>>>>>>
> >>>>>>>>>>> If you accept that of the infinitely many possible
> >>>>>>>>>>> functions Hx, none of them do a correct simulation
> >>>>>>>>>> It is stipulated that I just provided such a function.
> >>>>>>>>>> Here it is again named differently:
> >>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>> {
> >>>>>>>>>> x86_emulate(x,y);
> >>>>>>>>>> return 1;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> Hx function that is computationally equivalent to the
> >>>>>>>>>> above: int Hx(ptr x, ptr y)
> >>>>>>>>>> {
> >>>>>>>>>> x(y);
> >>>>>>>>>> return 1;
> >>>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> Fair enough. I ask you the questions a second time and you
> >>>>>>>>> just snip them again. You've provided one function which
> >>>>>>>>> simply calls another, unshown, function, so we can't have a
> >>>>>>>>> clue what it does. You've also said it is "computationally
> >>>>>>>>> equivalent" (whatever that means) to a function which won't
> >>>>>>>>> return a value. I can only assume that you know full well
> >>>>>>>>> that no functions provide a correct result for Px and that
> >>>>>>>>> you are simply trying to bluff. There's no reason to further
> >>>>>>>>> try to persuade you that you're wrong, you apparently know
> >>>>>>>>> it already.
> >>>>>>>>
> >>>>>>>> So you still don't understand that all simulating halt
> >>>>>>>> deciders PREDICT that their complete simulation of their
> >>>>>>>> input would never reach the final state of this simulated
> >>>>>>>> input without actually performing a complete simulation of
> >>>>>>>> this non-terminating input?
> >>>>>>>>
> >>>>>>>> *I have told you this dozens of times and you still don't get
> >>>>>>>> it*?
> >>>>>>>>
> >>>>>>>> void Infinite_Loop()
> >>>>>>>> {
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> _Infinite_Loop()
> >>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>>>> [00001107](01) 5d pop ebp
> >>>>>>>> [00001108](01) c3 ret
> >>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>
> >>>>>>>> H0: Begin Simulation Execution Trace Stored at:211fac
> >>>>>>>> [00001102][00211f9c][00211fa0] 55 push ebp
> >>>>>>>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
> >>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> >>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> >>>>>>>> H0: Infinite Loop Detected Simulation Stopped
> >>>>>>>>
> >>>>>>>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF _Infinite_Loop()
> >>>>>>>> YET STILL CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION
> >>>>>>>> WOULD NEVER HALT.
> >>>>>>>
> >>>>>>> Detecting non-halting is different to aborting a simulation
> >>>>>>> because the decider is incorrectly designed using recursion.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>>
> >>>>>>
> >>>>>> *It* is easy to verify that HH(PP,PP) is correctly designed to
> >>>>>> do recursive simulation. This was the hardest part of the
> >>>>>> entire design. https://liarparadox.org/2022_09_07.zip
> >>>>>>
> >>>>>> Each emulation requires its own process context including its
> >>>>>> own stack space.
> >>>>>
> >>>>> Recursive simulation is the wrong approach as a halting decider
> >>>>> is supposed to always return a result to its caller. The
> >>>>> Flibble Signaling Halt Decider (tm) is a simulating halt
> >>>>> decider that does not rely on recursion.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> If an input specifies infinitely recursive simulation then its
> >>>> correct simulation requires this.
> >>>
> >>> That isn't what I said. Again: a decider does not have to be
> >>> recursive in order to simulate something that is recursive.
> >>
> >> If an input to a simulator specifies recursive simulation then any
> >> simulator that does not implement recursive simulation is
> >> incorrect.
> >
> > That isn't what I said. Again: a decider does not have to be
> > recursive in order to simulate something that is recursive.
> >
> > /Flibble
> >
>
> So you agree that a simulator must be able to do recursive simulation
> when it is called in recursive simulation.

On 9/12/2022 3:55 PM, Mr Flibble wrote:
> On Mon, 12 Sep 2022 12:45:13 -0500
> olcott <none-ya@beez-wax.com> wrote:
>
>> On 9/11/2022 2:54 PM, Mr Flibble wrote:
>>> On Sun, 11 Sep 2022 14:40:40 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 9/11/2022 2:23 PM, Mr Flibble wrote:
>>>>> On Sun, 11 Sep 2022 10:03:20 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 9/10/2022 7:56 PM, Mr Flibble wrote:
>>>>>>> On Sat, 10 Sep 2022 15:55:35 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 9/10/2022 3:29 PM, Mr Flibble wrote:
>>>>>>>>> On Sat, 10 Sep 2022 15:24:39 -0500
>>>>>>>>> olcott <none-ya@beez-wax.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 9/10/2022 2:44 PM, Paul N wrote:
>>>>>>>>>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1, olcott
>>>>>>>>>>> wrote:
>>>>>>>>>>>> On 9/10/2022 2:06 PM, Paul N wrote:
>>>>>>>>>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1,
>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1,
>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
>>>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM
>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08
>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:09:44 AM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status =
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x); if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return; }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does any complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx ever stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> zero then Px halts, and if Hx returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-zero then Px does not halt. So Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can never do a complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px and return the right
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are discussing the infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just to clarify, we're talking about pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx and Px where the Px of the pair calls
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Hx of the pair as in the code above,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but we're not putting any restrictions on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what Hx does?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> An infinite subset of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these do a complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of their input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pair correctly predicts whether the Px of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pair halts, then no, they ALL get it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong, as shown above.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this subset would remain stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely recursive simulation such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px never reaches its final state and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation never stops, thus Hx never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns any value.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This point is moot, there are no pairs in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this subset.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into ancient
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Egyptian.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and makes all the moves where Deep
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Blue beat Garry Kasparov in the famous
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sixth match.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) An infinite subset of the *remaining
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subsets* ignores its input and returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> each element of the set of integers,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus one of them returns 1 and another
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, this one is called the *wild
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> guess halt decider*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of the wild guess deciders will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. The one always guessing 0 will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The one always guessing 1 will always be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong for Px, its Px will not halt. Follow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the code of Px if you don't believe me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (4) One of these implements the algorithm
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of my simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And this one will be wrong too, see above.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When it is the job of the halt decider to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predict whether or not its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would halt even the *wild guess
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider* element of subset (3) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt, but Px does halt. Try running it!
>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx never halt therefore any damn thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that says: "all correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px by Hx never halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>> therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Firstly, I see that you have ignored almost
>>>>>>>>>>>>>>>>>>>>>>>>>>> all of what I wrote and are headed off in a
>>>>>>>>>>>>>>>>>>>>>>>>>>> different direction. I wonder why?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So you don't understand the above point that
>>>>>>>>>>>>>>>>>>>>>>>>>> applies to every program that return 0?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If you mean the four lines just above, no, I
>>>>>>>>>>>>>>>>>>>>>>>>> am not clear what they say. I'm not even sure
>>>>>>>>>>>>>>>>>>>>>>>>> you know what they say. I think you need some
>>>>>>>>>>>>>>>>>>>>>>>>> words after the second "therefore" to make
>>>>>>>>>>>>>>>>>>>>>>>>> them make sense.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>> The code for Px is fully specified. The code
>>>>>>>>>>>>>>>>>>>>>>>> for Hx is the infinite set of every C function
>>>>>>>>>>>>>>>>>>>>>>>> that takes a pair of ptr arguments. These
>>>>>>>>>>>>>>>>>>>>>>>> arguments can be ignored, summed together,
>>>>>>>>>>>>>>>>>>>>>>>> multiplied together, simulated, or anything
>>>>>>>>>>>>>>>>>>>>>>>> else. One element of Hx ignores its arguments,
>>>>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into ancient
>>>>>>>>>>>>>>>>>>>>>>>> Egyptian and returns 56.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A subset of these C functions perform a correct
>>>>>>>>>>>>>>>>>>>>>>>> partial or complete simulation of their input.
>>>>>>>>>>>>>>>>>>>>>>>> In none of the elements of this set does Px
>>>>>>>>>>>>>>>>>>>>>>>> ever reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A subset of the original set return a value of
>>>>>>>>>>>>>>>>>>>>>>>> 0, which turns out to be the correct answer to
>>>>>>>>>>>>>>>>>>>>>>>> the question:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Does there exist any element of the infinite
>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such that Px correctly
>>>>>>>>>>>>>>>>>>>>>>>> simulated by Hx reaches the final state of Px?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> One element of the prior set correctly matches
>>>>>>>>>>>>>>>>>>>>>>>> a correct infinite behavior pattern, aborts the
>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input on the basis and
>>>>>>>>>>>>>>>>>>>>>>>> returns 0.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You've quoted the code of Px above, are you
>>>>>>>>>>>>>>>>>>>>>>> really incapable of actually understanding it?
>>>>>>>>>>>>>>>>>>>>>>> Let's see:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that
>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x) returns 0, so Halt_Status is set to
>>>>>>>>>>>>>>>>>>>>>>> zero
>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so
>>>>>>>>>>>>>>>>>>>>>>>> this "if" fails... HERE: goto HERE; // ... and
>>>>>>>>>>>>>>>>>>>>>>>> so this line is not executed ... return; //
>>>>>>>>>>>>>>>>>>>>>>>> ... and we get to here. }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So Px halts. There is no infinite behaviour
>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>> I have to update my last reply because I realized
>>>>>>>>>>>>>>>>>>>>>> that it was not accurate. I really only want an
>>>>>>>>>>>>>>>>>>>>>> honest dialogue and I incorrectly said that you
>>>>>>>>>>>>>>>>>>>>>> made a mistake that you did not make.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Thank you for this. Yes, I was saying that if
>>>>>>>>>>>>>>>>>>>>> Hx(Px, Px) returns 0 then Px halts.
>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider (SHD) only reports on
>>>>>>>>>>>>>>>>>>>>>> the behavior of what its complete and correct
>>>>>>>>>>>>>>>>>>>>>> simulation of its input would be, it never
>>>>>>>>>>>>>>>>>>>>>> reports on the actual behavior of what its
>>>>>>>>>>>>>>>>>>>>>> partial simulation is.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If a SHD reported on whether or not its input
>>>>>>>>>>>>>>>>>>>>>> stopped running then in those cases where the
>>>>>>>>>>>>>>>>>>>>>> simulated input stopped on its own and those
>>>>>>>>>>>>>>>>>>>>>> cases where the simulation was aborted the
>>>>>>>>>>>>>>>>>>>>>> simulated input stopped running. This derives a
>>>>>>>>>>>>>>>>>>>>>> correct halt decider with no discernment every
>>>>>>>>>>>>>>>>>>>>>> input is reported to stop running.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> To allow a SHD to have discernment it answers a
>>>>>>>>>>>>>>>>>>>>>> different question: Does any correct simulation
>>>>>>>>>>>>>>>>>>>>>> of its input reach the final state of this
>>>>>>>>>>>>>>>>>>>>>> input?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The snag is that Hx must always give the wrong
>>>>>>>>>>>>>>>>>>>>> answer for Px,
>>>>>>>>>>>>>>>>>>>> That is not true. Of the infinite set of Hx that
>>>>>>>>>>>>>>>>>>>> correctly simulate Px none ever reach the final
>>>>>>>>>>>>>>>>>>>> state of Px.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I assume when you say "Hx that correctly simulate
>>>>>>>>>>>>>>>>>>> Px" you're not just talking about what Hx does
>>>>>>>>>>>>>>>>>>> internally, you are also saying that Hx returns the
>>>>>>>>>>>>>>>>>>> correct answer in a finite time. (If this is not
>>>>>>>>>>>>>>>>>>> what you mean then please spell out what you do
>>>>>>>>>>>>>>>>>>> mean more clearly.)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> As I've said before, there is not an infinite set of
>>>>>>>>>>>>>>>>>>> Hx that correctly simulate Px. EVERY Hx gets its
>>>>>>>>>>>>>>>>>>> corresponding Px wrong.
>>>>>>>>>>>>>>>>>>>> Every simulating halt decider must only predict the
>>>>>>>>>>>>>>>>>>>> behavior of what its correct and complete
>>>>>>>>>>>>>>>>>>>> simulation of its input would be and the must not
>>>>>>>>>>>>>>>>>>>> report on the actual behavior of its partial
>>>>>>>>>>>>>>>>>>>> simulation. void Infinite_Loop() {
>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>> When H0 reports that its correct and complete
>>>>>>>>>>>>>>>>>>>> simulation of its input Infinite_Loop() would never
>>>>>>>>>>>>>>>>>>>> reach the final state of this simulated input it
>>>>>>>>>>>>>>>>>>>> has a sound basis.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes, there's no problem with this function and no
>>>>>>>>>>>>>>>>>>> reason why Hx need get it wrong. You've said that
>>>>>>>>>>>>>>>>>>> you have written an Hx which correctly handles this
>>>>>>>>>>>>>>>>>>> case and I have no reason to doubt this.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The problem with Px is that it necessarily does the
>>>>>>>>>>>>>>>>>>> opposite of what Hx predicts it will.
>>>>>>>>>>>>>>>>>> You must have not been paying hardly and attention at
>>>>>>>>>>>>>>>>>> all.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input to
>>>>>>>>>>>>>>>>>> Hx(P,P) by Hx* (a) Hx(P,P) simulates P(P) that calls
>>>>>>>>>>>>>>>>>> a simulated Hx(P,P) (b) that simulates P(P) that
>>>>>>>>>>>>>>>>>> calls a simulated Hx(P,P) (c) that simulates P(P)
>>>>>>>>>>>>>>>>>> that calls a simulated Hx(P,P) (d) that simulates
>>>>>>>>>>>>>>>>>> P(P) that calls a simulated Hx(P,P)...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nonsense. You've told us many times that Hx does not
>>>>>>>>>>>>>>>>> behave like this. So it is not a correct simulation to
>>>>>>>>>>>>>>>>> pretend that it does.
>>>>>>>>>>>>>>>> Hx is not the same as H. As I have told you several
>>>>>>>>>>>>>>>> times now, the Hx/Px pairs are the infinite set of
>>>>>>>>>>>>>>>> every encoding of Hx. I am going to stop right here
>>>>>>>>>>>>>>>> and not proceed to another point until you fully
>>>>>>>>>>>>>>>> understand and accept this point.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> OK then. You are saying that there are infinitely many
>>>>>>>>>>>>>>> possible functions Hx, and that of these, infinitely
>>>>>>>>>>>>>>> many do a correct simulation of the corresponding Px. I
>>>>>>>>>>>>>>> am saying that while here are infinitely many possible
>>>>>>>>>>>>>>> functions Hx, none of them do a correct simulation of
>>>>>>>>>>>>>>> the corresponding Px.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> // An Infinite number of different halting computations
>>>>>>>>>>>>>> can precede this: Simulate(x,y);
>>>>>>>>>>>>>> return 1;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Hx(Px,Px);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> You've completely failed to answer any of the questions!
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you accept that of the infinitely many possible
>>>>>>>>>>>>> functions Hx, none of them do a correct simulation
>>>>>>>>>>>> It is stipulated that I just provided such a function.
>>>>>>>>>>>> Here it is again named differently:
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>> x86_emulate(x,y);
>>>>>>>>>>>> return 1;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Hx function that is computationally equivalent to the
>>>>>>>>>>>> above: int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>> x(y);
>>>>>>>>>>>> return 1;
>>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Fair enough. I ask you the questions a second time and you
>>>>>>>>>>> just snip them again. You've provided one function which
>>>>>>>>>>> simply calls another, unshown, function, so we can't have a
>>>>>>>>>>> clue what it does. You've also said it is "computationally
>>>>>>>>>>> equivalent" (whatever that means) to a function which won't
>>>>>>>>>>> return a value. I can only assume that you know full well
>>>>>>>>>>> that no functions provide a correct result for Px and that
>>>>>>>>>>> you are simply trying to bluff. There's no reason to further
>>>>>>>>>>> try to persuade you that you're wrong, you apparently know
>>>>>>>>>>> it already.
>>>>>>>>>>
>>>>>>>>>> So you still don't understand that all simulating halt
>>>>>>>>>> deciders PREDICT that their complete simulation of their
>>>>>>>>>> input would never reach the final state of this simulated
>>>>>>>>>> input without actually performing a complete simulation of
>>>>>>>>>> this non-terminating input?
>>>>>>>>>>
>>>>>>>>>> *I have told you this dozens of times and you still don't get
>>>>>>>>>> it*?
>>>>>>>>>>
>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>> {
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>
>>>>>>>>>> H0: Begin Simulation Execution Trace Stored at:211fac
>>>>>>>>>> [00001102][00211f9c][00211fa0] 55 push ebp
>>>>>>>>>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
>>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
>>>>>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>>>>>
>>>>>>>>>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF _Infinite_Loop()
>>>>>>>>>> YET STILL CORRECTLY PREDICTS THAT SUCH A COMPLETE SIMULATION
>>>>>>>>>> WOULD NEVER HALT.
>>>>>>>>>
>>>>>>>>> Detecting non-halting is different to aborting a simulation
>>>>>>>>> because the decider is incorrectly designed using recursion.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> *It* is easy to verify that HH(PP,PP) is correctly designed to
>>>>>>>> do recursive simulation. This was the hardest part of the
>>>>>>>> entire design. https://liarparadox.org/2022_09_07.zip
>>>>>>>>
>>>>>>>> Each emulation requires its own process context including its
>>>>>>>> own stack space.
>>>>>>>
>>>>>>> Recursive simulation is the wrong approach as a halting decider
>>>>>>> is supposed to always return a result to its caller. The
>>>>>>> Flibble Signaling Halt Decider (tm) is a simulating halt
>>>>>>> decider that does not rely on recursion.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> If an input specifies infinitely recursive simulation then its
>>>>>> correct simulation requires this.
>>>>>
>>>>> That isn't what I said. Again: a decider does not have to be
>>>>> recursive in order to simulate something that is recursive.
>>>>
>>>> If an input to a simulator specifies recursive simulation then any
>>>> simulator that does not implement recursive simulation is
>>>> incorrect.
>>>
>>> That isn't what I said. Again: a decider does not have to be
>>> recursive in order to simulate something that is recursive.
>>>
>>> /Flibble
>>>
>>
>> So you agree that a simulator must be able to do recursive simulation
>> when it is called in recursive simulation.
>
> Px isn't recursively calling H,

On Mon, 12 Sep 2022 16:08:46 -0500
olcott <none-ya@beez-wax.com> wrote:

> On 9/12/2022 3:55 PM, Mr Flibble wrote:
> > On Mon, 12 Sep 2022 12:45:13 -0500
> > olcott <none-ya@beez-wax.com> wrote:
> >
> >> On 9/11/2022 2:54 PM, Mr Flibble wrote:
> >>> On Sun, 11 Sep 2022 14:40:40 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 9/11/2022 2:23 PM, Mr Flibble wrote:
> >>>>> On Sun, 11 Sep 2022 10:03:20 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 9/10/2022 7:56 PM, Mr Flibble wrote:
> >>>>>>> On Sat, 10 Sep 2022 15:55:35 -0500
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 9/10/2022 3:29 PM, Mr Flibble wrote:
> >>>>>>>>> On Sat, 10 Sep 2022 15:24:39 -0500
> >>>>>>>>> olcott <none-ya@beez-wax.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 9/10/2022 2:44 PM, Paul N wrote:
> >>>>>>>>>>> On Saturday, September 10, 2022 at 8:31:16 PM UTC+1,
> >>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>> On 9/10/2022 2:06 PM, Paul N wrote:
> >>>>>>>>>>>>> On Saturday, September 10, 2022 at 6:57:30 PM UTC+1,
> >>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>> On 9/10/2022 12:44 PM, Paul N wrote:
> >>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 5:49:56 PM UTC+1,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>> On 9/10/2022 11:30 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>> On Saturday, September 10, 2022 at 2:58:21 PM UTC+1,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>> On 9/10/2022 6:39 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:47:11 PM UTC+1,
> >>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 9/9/2022 2:31 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 8:10:10 PM
> >>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 1:36 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 7:16:42 PM
> >>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 12:49 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 9, 2022 at 3:19:07 PM
> >>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at 11:34:08
> >>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:50:20 PM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thursday, September 8, 2022 at
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:09:44 AM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/6/22 1:56
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt_Status =
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x, x); if
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE; return; }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = ", Hx(Px,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does any complete and correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx ever stop
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can easily see that if Hx returns
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> zero then Px halts, and if Hx returns
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-zero then Px does not halt. So Hx
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can never do a complete and correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px and return the right
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We will call this the UTM subset*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are discussing the infinite set of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just to clarify, we're talking about
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs Hx and Px where the Px of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> pair calls the Hx of the pair as in the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> code above, but we're not putting any
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> restrictions on what Hx does?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> An infinite subset of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these do a complete and correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of their input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> If by this you mean that the Hx of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> pair correctly predicts whether the Px
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the pair halts, then no, they ALL
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> get it wrong, as shown above.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Perhaps you fail to comprehend that all
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this subset would remain stuck in
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely recursive simulation such
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Px never reaches its final state
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and the simulation never stops, thus
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx never returns any value.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This point is moot, there are no pairs
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> in this subset.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Of the remaining subsets*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) One of these ignores its input and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> translates the Lord's prayer into
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ancient Egyptian.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Another one of these ignores its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and makes all the moves where
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deep Blue beat Garry Kasparov in the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> famous sixth match.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) An infinite subset of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *remaining subsets* ignores its input
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and returns each element of the set of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> integers, thus one of them returns 1
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and another returns 0, this one is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called the *wild guess halt decider*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of the wild guess deciders will be
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. The one always guessing 0 will
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt. The one always guessing 1 will
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> always be wrong for Px, its Px will not
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt. Follow the code of Px if you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't believe me.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (4) One of these implements the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm of my simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> And this one will be wrong too, see
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> above.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When it is the job of the halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to correctly predict whether or not its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would halt even the *wild guess
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider* element of subset (3) is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, this is wrong, it predicts Px will
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt, but Px does halt. Try running
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> it!
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> all correct and complete simulations of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx never halt therefore any damn
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> thing that says: "all correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations of Px by Hx never
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> halt therefore" *IS NECESSARILY CORRECT*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Firstly, I see that you have ignored
> >>>>>>>>>>>>>>>>>>>>>>>>>>> almost all of what I wrote and are headed
> >>>>>>>>>>>>>>>>>>>>>>>>>>> off in a different direction. I wonder
> >>>>>>>>>>>>>>>>>>>>>>>>>>> why?
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> So you don't understand the above point
> >>>>>>>>>>>>>>>>>>>>>>>>>> that applies to every program that return
> >>>>>>>>>>>>>>>>>>>>>>>>>> 0?
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> If you mean the four lines just above, no, I
> >>>>>>>>>>>>>>>>>>>>>>>>> am not clear what they say. I'm not even
> >>>>>>>>>>>>>>>>>>>>>>>>> sure you know what they say. I think you
> >>>>>>>>>>>>>>>>>>>>>>>>> need some words after the second
> >>>>>>>>>>>>>>>>>>>>>>>>> "therefore" to make them make sense.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>> The code for Px is fully specified. The code
> >>>>>>>>>>>>>>>>>>>>>>>> for Hx is the infinite set of every C
> >>>>>>>>>>>>>>>>>>>>>>>> function that takes a pair of ptr arguments.
> >>>>>>>>>>>>>>>>>>>>>>>> These arguments can be ignored, summed
> >>>>>>>>>>>>>>>>>>>>>>>> together, multiplied together, simulated, or
> >>>>>>>>>>>>>>>>>>>>>>>> anything else. One element of Hx ignores its
> >>>>>>>>>>>>>>>>>>>>>>>> arguments, translates the Lord's prayer into
> >>>>>>>>>>>>>>>>>>>>>>>> ancient Egyptian and returns 56.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> A subset of these C functions perform a
> >>>>>>>>>>>>>>>>>>>>>>>> correct partial or complete simulation of
> >>>>>>>>>>>>>>>>>>>>>>>> their input. In none of the elements of this
> >>>>>>>>>>>>>>>>>>>>>>>> set does Px ever reach its final state.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> A subset of the original set return a value
> >>>>>>>>>>>>>>>>>>>>>>>> of 0, which turns out to be the correct
> >>>>>>>>>>>>>>>>>>>>>>>> answer to the question:
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Does there exist any element of the infinite
> >>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such that Px correctly
> >>>>>>>>>>>>>>>>>>>>>>>> simulated by Hx reaches the final state of
> >>>>>>>>>>>>>>>>>>>>>>>> Px?
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> One element of the prior set correctly
> >>>>>>>>>>>>>>>>>>>>>>>> matches a correct infinite behavior pattern,
> >>>>>>>>>>>>>>>>>>>>>>>> aborts the simulation of its input on the
> >>>>>>>>>>>>>>>>>>>>>>>> basis and returns 0.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> You've quoted the code of Px above, are you
> >>>>>>>>>>>>>>>>>>>>>>> really incapable of actually understanding it?
> >>>>>>>>>>>>>>>>>>>>>>> Let's see:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x); // you say that
> >>>>>>>>>>>>>>>>>>>>>>> Hx(x, x) returns 0, so Halt_Status is set to
> >>>>>>>>>>>>>>>>>>>>>>> zero
> >>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // Halt_Status is zero, so
> >>>>>>>>>>>>>>>>>>>>>>>> this "if" fails... HERE: goto HERE; // ...
> >>>>>>>>>>>>>>>>>>>>>>>> and so this line is not executed ... return;
> >>>>>>>>>>>>>>>>>>>>>>>> // ... and we get to here. }
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> So Px halts. There is no infinite behaviour
> >>>>>>>>>>>>>>>>>>>>>>> pattern.
> >>>>>>>>>>>>>>>>>>>>>> I have to update my last reply because I
> >>>>>>>>>>>>>>>>>>>>>> realized that it was not accurate. I really
> >>>>>>>>>>>>>>>>>>>>>> only want an honest dialogue and I incorrectly
> >>>>>>>>>>>>>>>>>>>>>> said that you made a mistake that you did not
> >>>>>>>>>>>>>>>>>>>>>> make.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Thank you for this. Yes, I was saying that if
> >>>>>>>>>>>>>>>>>>>>> Hx(Px, Px) returns 0 then Px halts.
> >>>>>>>>>>>>>>>>>>>>>> A simulating halt decider (SHD) only reports on
> >>>>>>>>>>>>>>>>>>>>>> the behavior of what its complete and correct
> >>>>>>>>>>>>>>>>>>>>>> simulation of its input would be, it never
> >>>>>>>>>>>>>>>>>>>>>> reports on the actual behavior of what its
> >>>>>>>>>>>>>>>>>>>>>> partial simulation is.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> If a SHD reported on whether or not its input
> >>>>>>>>>>>>>>>>>>>>>> stopped running then in those cases where the
> >>>>>>>>>>>>>>>>>>>>>> simulated input stopped on its own and those
> >>>>>>>>>>>>>>>>>>>>>> cases where the simulation was aborted the
> >>>>>>>>>>>>>>>>>>>>>> simulated input stopped running. This derives a
> >>>>>>>>>>>>>>>>>>>>>> correct halt decider with no discernment every
> >>>>>>>>>>>>>>>>>>>>>> input is reported to stop running.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> To allow a SHD to have discernment it answers a
> >>>>>>>>>>>>>>>>>>>>>> different question: Does any correct simulation
> >>>>>>>>>>>>>>>>>>>>>> of its input reach the final state of this
> >>>>>>>>>>>>>>>>>>>>>> input?
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The snag is that Hx must always give the wrong
> >>>>>>>>>>>>>>>>>>>>> answer for Px,
> >>>>>>>>>>>>>>>>>>>> That is not true. Of the infinite set of Hx that
> >>>>>>>>>>>>>>>>>>>> correctly simulate Px none ever reach the final
> >>>>>>>>>>>>>>>>>>>> state of Px.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> I assume when you say "Hx that correctly simulate
> >>>>>>>>>>>>>>>>>>> Px" you're not just talking about what Hx does
> >>>>>>>>>>>>>>>>>>> internally, you are also saying that Hx returns
> >>>>>>>>>>>>>>>>>>> the correct answer in a finite time. (If this is
> >>>>>>>>>>>>>>>>>>> not what you mean then please spell out what you
> >>>>>>>>>>>>>>>>>>> do mean more clearly.)
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> As I've said before, there is not an infinite set
> >>>>>>>>>>>>>>>>>>> of Hx that correctly simulate Px. EVERY Hx gets
> >>>>>>>>>>>>>>>>>>> its corresponding Px wrong.
> >>>>>>>>>>>>>>>>>>>> Every simulating halt decider must only predict
> >>>>>>>>>>>>>>>>>>>> the behavior of what its correct and complete
> >>>>>>>>>>>>>>>>>>>> simulation of its input would be and the must not
> >>>>>>>>>>>>>>>>>>>> report on the actual behavior of its partial
> >>>>>>>>>>>>>>>>>>>> simulation. void Infinite_Loop() {
> >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>> When H0 reports that its correct and complete
> >>>>>>>>>>>>>>>>>>>> simulation of its input Infinite_Loop() would
> >>>>>>>>>>>>>>>>>>>> never reach the final state of this simulated
> >>>>>>>>>>>>>>>>>>>> input it has a sound basis.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Yes, there's no problem with this function and no
> >>>>>>>>>>>>>>>>>>> reason why Hx need get it wrong. You've said that
> >>>>>>>>>>>>>>>>>>> you have written an Hx which correctly handles
> >>>>>>>>>>>>>>>>>>> this case and I have no reason to doubt this.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The problem with Px is that it necessarily does
> >>>>>>>>>>>>>>>>>>> the opposite of what Hx predicts it will.
> >>>>>>>>>>>>>>>>>> You must have not been paying hardly and attention
> >>>>>>>>>>>>>>>>>> at all.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
> >>>>>>>>>>>>>>>>>> to Hx(P,P) by Hx* (a) Hx(P,P) simulates P(P) that
> >>>>>>>>>>>>>>>>>> calls a simulated Hx(P,P) (b) that simulates P(P)
> >>>>>>>>>>>>>>>>>> that calls a simulated Hx(P,P) (c) that simulates
> >>>>>>>>>>>>>>>>>> P(P) that calls a simulated Hx(P,P) (d) that
> >>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated Hx(P,P)...
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Nonsense. You've told us many times that Hx does not
> >>>>>>>>>>>>>>>>> behave like this. So it is not a correct simulation
> >>>>>>>>>>>>>>>>> to pretend that it does.
> >>>>>>>>>>>>>>>> Hx is not the same as H. As I have told you several
> >>>>>>>>>>>>>>>> times now, the Hx/Px pairs are the infinite set of
> >>>>>>>>>>>>>>>> every encoding of Hx. I am going to stop right here
> >>>>>>>>>>>>>>>> and not proceed to another point until you fully
> >>>>>>>>>>>>>>>> understand and accept this point.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> OK then. You are saying that there are infinitely many
> >>>>>>>>>>>>>>> possible functions Hx, and that of these, infinitely
> >>>>>>>>>>>>>>> many do a correct simulation of the corresponding Px.
> >>>>>>>>>>>>>>> I am saying that while here are infinitely many
> >>>>>>>>>>>>>>> possible functions Hx, none of them do a correct
> >>>>>>>>>>>>>>> simulation of the corresponding Px.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> // An Infinite number of different halting computations
> >>>>>>>>>>>>>> can precede this: Simulate(x,y);
> >>>>>>>>>>>>>> return 1;
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> Hx(Px,Px);
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> You've completely failed to answer any of the questions!
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If you accept that of the infinitely many possible
> >>>>>>>>>>>>> functions Hx, none of them do a correct simulation
> >>>>>>>>>>>> It is stipulated that I just provided such a function.
> >>>>>>>>>>>> Here it is again named differently:
> >>>>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> x86_emulate(x,y);
> >>>>>>>>>>>> return 1;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> Hx function that is computationally equivalent to the
> >>>>>>>>>>>> above: int Hx(ptr x, ptr y)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> x(y);
> >>>>>>>>>>>> return 1;
> >>>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> Fair enough. I ask you the questions a second time and you
> >>>>>>>>>>> just snip them again. You've provided one function which
> >>>>>>>>>>> simply calls another, unshown, function, so we can't have
> >>>>>>>>>>> a clue what it does. You've also said it is
> >>>>>>>>>>> "computationally equivalent" (whatever that means) to a
> >>>>>>>>>>> function which won't return a value. I can only assume
> >>>>>>>>>>> that you know full well that no functions provide a
> >>>>>>>>>>> correct result for Px and that you are simply trying to
> >>>>>>>>>>> bluff. There's no reason to further try to persuade you
> >>>>>>>>>>> that you're wrong, you apparently know it already.
> >>>>>>>>>>
> >>>>>>>>>> So you still don't understand that all simulating halt
> >>>>>>>>>> deciders PREDICT that their complete simulation of their
> >>>>>>>>>> input would never reach the final state of this simulated
> >>>>>>>>>> input without actually performing a complete simulation of
> >>>>>>>>>> this non-terminating input?
> >>>>>>>>>>
> >>>>>>>>>> *I have told you this dozens of times and you still don't
> >>>>>>>>>> get it*?
> >>>>>>>>>>
> >>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>> {
> >>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>>>>>> [00001107](01) 5d pop ebp
> >>>>>>>>>> [00001108](01) c3 ret
> >>>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>>
> >>>>>>>>>> H0: Begin Simulation Execution Trace Stored at:211fac
> >>>>>>>>>> [00001102][00211f9c][00211fa0] 55 push ebp
> >>>>>>>>>> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
> >>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> >>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> >>>>>>>>>> H0: Infinite Loop Detected Simulation Stopped
> >>>>>>>>>>
> >>>>>>>>>> H0 DOES NOT PERFORM A COMPLETE SIMULATION OF
> >>>>>>>>>> _Infinite_Loop() YET STILL CORRECTLY PREDICTS THAT SUCH A
> >>>>>>>>>> COMPLETE SIMULATION WOULD NEVER HALT.
> >>>>>>>>>
> >>>>>>>>> Detecting non-halting is different to aborting a simulation
> >>>>>>>>> because the decider is incorrectly designed using recursion.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> *It* is easy to verify that HH(PP,PP) is correctly designed
> >>>>>>>> to do recursive simulation. This was the hardest part of the
> >>>>>>>> entire design. https://liarparadox.org/2022_09_07.zip
> >>>>>>>>
> >>>>>>>> Each emulation requires its own process context including its
> >>>>>>>> own stack space.
> >>>>>>>
> >>>>>>> Recursive simulation is the wrong approach as a halting
> >>>>>>> decider is supposed to always return a result to its caller.
> >>>>>>> The Flibble Signaling Halt Decider (tm) is a simulating halt
> >>>>>>> decider that does not rely on recursion.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> If an input specifies infinitely recursive simulation then its
> >>>>>> correct simulation requires this.
> >>>>>
> >>>>> That isn't what I said. Again: a decider does not have to be
> >>>>> recursive in order to simulate something that is recursive.
> >>>>
> >>>> If an input to a simulator specifies recursive simulation then
> >>>> any simulator that does not implement recursive simulation is
> >>>> incorrect.
> >>>
> >>> That isn't what I said. Again: a decider does not have to be
> >>> recursive in order to simulate something that is recursive.
> >>>
> >>> /Flibble
> >>>
> >>
> >> So you agree that a simulator must be able to do recursive
> >> simulation when it is called in recursive simulation.
> >
> > Px isn't recursively calling H,
>
> You are changing the subject, please stay with the actual question
> that I actually asked instead of looking for one excuse or another to
> disagree.
>
> > it is just calling H and it expects it
> > to return to Px with a halting decision as that is what halt
> > deciders are supposed to do.
> >
> > /Flibble
> >
>