On 8/26/22 10:36 PM, olcott wrote:
> On 8/26/2022 8:59 PM, Richard Damon wrote:
>> On 8/26/22 9:44 PM, olcott wrote:
>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>> On 8/26/22 8:13 PM, olcott wrote:

>>>>> In none of these cases will the simulated P(P) ever reach its own
>>>>> final state:
>>>>>
>>>>> void Px(u32 x)
>>>>> {
>>>>>     H(x, x);
>>>>>     return;
>>>>> }
>>>>
>>>> ^ This will when it is CORRECTLY and COMPLETELY Simulated, since
>>>> H(Px,Px) has been shown to return 0 in finite time.
>>>
>>> So maybe you are as clueless as Flibble.
>>>
>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>
>>> Whether H simulates its input once or allows the recursive
>>> simulations to continue forever there is never a case where simulated
>>> Px ever reaches its final state.
>>>
>>> When H aborts its simulated input it never again simulates a single
>>> instruction of its input thus all recursive emulations are
>>> immediately dead in the water and cannot return to their caller.
>>>
>>>
>>
>>
>> No, it doesn't. May be you don't know your own code, or you are just a
>> LIAR.
>>
>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at which point
>> the original H(P,P) aborts its simulation and returns 0.
>>
>> THAT is what you code does.
>>
>> That means that a CORRECT and *COMPLETE* simulation of the input to
>> H(P,P) is:
>>
>> Simulator simulated P(P) calling H(P,P).
>> That H(P,P) is simulated to simulate a copy of P(P), and will simulate
>> to it calling H(P,P).
>> That simulated H(P,P) then aborts its simulation and is simulated to
>> return to the P(P) that the outer simulation is simulating.
>>
>> THat simulated P(P) will reach its final state and return.
>>
>> Please point out the error in that description.
>
> The executed H(P,P) simulates P(P) that calls the simulated H(P,P)
> that simulates P(P) that calls the simulated H(P,P)
> that simulates P(P) that calls the simulated H(P,P)
> that simulates P(P) that calls the simulated H(P,P)
> that simulates P(P) that calls the simulated H(P,P)
> until the executed H(P,P) aborts the whole chain causing everything else
> to immediately stop.
>
>

So, I said that, and the correct and complete simulation of the input
sees that in the simulate call to H(P,P) and then sees the simulate P(P)
reaching its final state.

You are just showing that H doesn't actually do a complete simulation of
its input, so it isn't the case needed to determine if the input is
non-halting.

You keep on going to your definition of POOP, and not Halting.

Halting is based on the behavior of the machine the input represents.

Your POOP is what is based on the INCOMPLETE simulation done by H.

Sorry Charlie, your answer just doesn't match the required definition.

On 8/26/2022 9:46 PM, Richard Damon wrote:
>
> On 8/26/22 10:36 PM, olcott wrote:
>> On 8/26/2022 8:59 PM, Richard Damon wrote:
>>> On 8/26/22 9:44 PM, olcott wrote:
>>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>>> On 8/26/22 8:13 PM, olcott wrote:
>
>>>>>> In none of these cases will the simulated P(P) ever reach its own
>>>>>> final state:
>>>>>>
>>>>>> void Px(u32 x)
>>>>>> {
>>>>>>     H(x, x);
>>>>>>     return;
>>>>>> }
>>>>>
>>>>> ^ This will when it is CORRECTLY and COMPLETELY Simulated, since
>>>>> H(Px,Px) has been shown to return 0 in finite time.
>>>>
>>>> So maybe you are as clueless as Flibble.
>>>>
>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>
>>>> Whether H simulates its input once or allows the recursive
>>>> simulations to continue forever there is never a case where
>>>> simulated Px ever reaches its final state.
>>>>
>>>> When H aborts its simulated input it never again simulates a single
>>>> instruction of its input thus all recursive emulations are
>>>> immediately dead in the water and cannot return to their caller.
>>>>
>>>>
>>>
>>>
>>> No, it doesn't. May be you don't know your own code, or you are just
>>> a LIAR.
>>>
>>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at which
>>> point the original H(P,P) aborts its simulation and returns 0.
>>>
>>> THAT is what you code does.
>>>
>>> That means that a CORRECT and *COMPLETE* simulation of the input to
>>> H(P,P) is:
>>>
>>> Simulator simulated P(P) calling H(P,P).
>>> That H(P,P) is simulated to simulate a copy of P(P), and will
>>> simulate to it calling H(P,P).
>>> That simulated H(P,P) then aborts its simulation and is simulated to
>>> return to the P(P) that the outer simulation is simulating.
>>>
>>> THat simulated P(P) will reach its final state and return.
>>>
>>> Please point out the error in that description.
>>
>> The executed H(P,P) simulates P(P) that calls the simulated H(P,P)
>> that simulates P(P) that calls the simulated H(P,P)
>> that simulates P(P) that calls the simulated H(P,P)
>> that simulates P(P) that calls the simulated H(P,P)
>> that simulates P(P) that calls the simulated H(P,P)
>> until the executed H(P,P) aborts the whole chain causing everything
>> else to immediately stop.
>>
>>
>
> So, I said that, and the correct and complete simulation of the input
> sees that in the simulate call to H(P,P) and then sees the simulate P(P)
> reaching its final state.
>

*You just don't seem to know enough about software engineering*
When the outermost executed H(P,P) aborts the simulation of its input
all of the simulations immediately stop because it was only the
outermost H that was driving them.

From the simulated P's point of view it is just like it hit an abnormal
termination core dump divide by zero error. No more steps are simulated.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 8/26/22 11:29 PM, olcott wrote:
> On 8/26/2022 9:46 PM, Richard Damon wrote:
>>
>> On 8/26/22 10:36 PM, olcott wrote:
>>> On 8/26/2022 8:59 PM, Richard Damon wrote:
>>>> On 8/26/22 9:44 PM, olcott wrote:
>>>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>>>> On 8/26/22 8:13 PM, olcott wrote:
>>
>>>>>>> In none of these cases will the simulated P(P) ever reach its own
>>>>>>> final state:
>>>>>>>
>>>>>>> void Px(u32 x)
>>>>>>> {
>>>>>>>     H(x, x);
>>>>>>>     return;
>>>>>>> }
>>>>>>
>>>>>> ^ This will when it is CORRECTLY and COMPLETELY Simulated, since
>>>>>> H(Px,Px) has been shown to return 0 in finite time.
>>>>>
>>>>> So maybe you are as clueless as Flibble.
>>>>>
>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>
>>>>> Whether H simulates its input once or allows the recursive
>>>>> simulations to continue forever there is never a case where
>>>>> simulated Px ever reaches its final state.
>>>>>
>>>>> When H aborts its simulated input it never again simulates a single
>>>>> instruction of its input thus all recursive emulations are
>>>>> immediately dead in the water and cannot return to their caller.
>>>>>
>>>>>
>>>>
>>>>
>>>> No, it doesn't. May be you don't know your own code, or you are just
>>>> a LIAR.
>>>>
>>>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at which
>>>> point the original H(P,P) aborts its simulation and returns 0.
>>>>
>>>> THAT is what you code does.
>>>>
>>>> That means that a CORRECT and *COMPLETE* simulation of the input to
>>>> H(P,P) is:
>>>>
>>>> Simulator simulated P(P) calling H(P,P).
>>>> That H(P,P) is simulated to simulate a copy of P(P), and will
>>>> simulate to it calling H(P,P).
>>>> That simulated H(P,P) then aborts its simulation and is simulated to
>>>> return to the P(P) that the outer simulation is simulating.
>>>>
>>>> THat simulated P(P) will reach its final state and return.
>>>>
>>>> Please point out the error in that description.
>>>
>>> The executed H(P,P) simulates P(P) that calls the simulated H(P,P)
>>> that simulates P(P) that calls the simulated H(P,P)
>>> that simulates P(P) that calls the simulated H(P,P)
>>> that simulates P(P) that calls the simulated H(P,P)
>>> that simulates P(P) that calls the simulated H(P,P)
>>> until the executed H(P,P) aborts the whole chain causing everything
>>> else to immediately stop.
>>>
>>>
>>
>> So, I said that, and the correct and complete simulation of the input
>> sees that in the simulate call to H(P,P) and then sees the simulate
>> P(P) reaching its final state.
>>
>
> *You just don't seem to know enough about software engineering*
> When the outermost executed H(P,P) aborts the simulation of its input
> all of the simulations immediately stop because it was only the
> outermost H that was driving them.
>
> From the simulated P's point of view it is just like it hit an abnormal
> termination core dump divide by zero error. No more steps are simulated.
>

No, you have your details wrong, at least if you intend to be working on
the Halting Problem. When H stops its simulation, the SIMULATION stops,
but the behavior of the simulated P doesn't "stop", it just becomes unknown.

The behavor of a correctly simulated P will exactly match the behavior
of the direct exectution of that same function P.

Here is a good practical example. You are watching the recording of a
sports game. At some point you turn off the device that you watch and
end the veiwing of the recording.

Did the game stop? No.

Did the recording end? No.

All that happened was you stopped watching the recording.

In the same way, when H stops simulating P, it doesn't "abort" P, it
aborts its viewing of the simulation of P. The behavior of P didn't
change, and the correct and complete behavior continues, and will Halt.

IF you want to define a decider that decides on its own simulation of an
input, that is fine, such a decider just isn't a Halt Decider, because,
BY DEFINITION, a Halt Decider decides on the actual behavior of the
machine that is given to it, not its own simulation of it.

So, yes, H may be a correct POOP decider, but it is NOT a correct Halt
Decider, and it appears that you have been eating your own POOP for so
long that you forget what real logic tastes like.

So sorry for bursting your bubble, but you are just proving how much of
an idiot you are for thinking that you know anything about Software
Enginieering, let alone Computer Science.

On Fri, 26 Aug 2022 19:13:09 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/26/2022 6:49 PM, Mr Flibble wrote:
> > On Fri, 26 Aug 2022 16:43:15 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/26/2022 4:23 PM, Mr Flibble wrote:
> >>> On Fri, 26 Aug 2022 16:06:19 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/26/2022 3:29 PM, Paul N wrote:
> >>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott wrote:
> >>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
> >>>>>>> On 8/26/22 3:34 PM, olcott wrote:
> >>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
> >>>>>>>>>
> >>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
> >>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
> >>>>>>>>>>>
> >>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
> >>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
> >>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM UTC+1,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM UTC+1,
> >>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
> >>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
> >>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25 PM
> >>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 3:50:37 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution trace of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the input by
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches line-by-line the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input never
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and stops
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> running: (a) H(P,P) simulates P(P) that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P) (d) that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)...
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> 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]
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your actual H.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
> >>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
> >>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
> >>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must always
> >>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
> >>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
> >>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
> >>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The behaviour of
> >>>>>>>>>>>>>>>>>>>>>>>>> P(P) is that it terminates, or so you
> >>>>>>>>>>>>>>>>>>>>>>>>> claim.
> >>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
> >>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
> >>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its input.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
> >>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
> >>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of a
> >>>>>>>>>>>>>>>>>>>>>> machine description always
> >>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
> >>>>>>>>>>>>>>>>>>>>>> machine description.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a complete
> >>>>>>>>>>>>>>>>>>>>> simulation.
> >>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
> >>>>>>>>>>>>>>>>>>>> correctly performs a
> >>>>>>>>>>>>>>>>>>>> partial simulation of its input and the behavior
> >>>>>>>>>>>>>>>>>>>> of this partial
> >>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
> >>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
> >>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
> >>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
> >>>>>>>>>>>>>>>>>>> that it doesn't.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
> >>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has entirely
> >>>>>>>>>>>>>>>>>> different behavior
> >>>>>>>>>>>>>>>>>> than the actual behavior specified by its actual
> >>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is P
> >>>>>>>>>>>>>>>>> and so H must report on what P does. The second
> >>>>>>>>>>>>>>>>> argument is also P and so specifically H must
> >>>>>>>>>>>>>>>>> report on what P(P) does. The idea that H(P, P) has
> >>>>>>>>>>>>>>>>> some sort of "input" which is not P is nonsense.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
> >>>>>>>>>>>>>>>>>> description always
> >>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
> >>>>>>>>>>>>>>>>>> machine description.
> >>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
> >>>>>>>>>>>>>>>>>> to H(P,P) by H*
> >>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated
> >>>>>>>>>>>>>>>>>> H(P,P) (b) that simulates P(P) that calls a
> >>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that calls
> >>>>>>>>>>>>>>>>>> a simulated H(P,P) (d) that simulates P(P) that
> >>>>>>>>>>>>>>>>>> calls a simulated H(P,P)...
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> You know this is not true, and putting it into
> >>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you twice
> >>>>>>>>>>>>>>>>> in the quotes above alone.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> That is what the correct and COMPLETE simulation of
> >>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and complete
> >>>>>>>>>>>>>>>> simulation of the input to H(P,P) is shown by
> >>>>>>>>>>>>>>>> replacing H() with Simulate().
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> You can't work out what an aborting H will do simply
> >>>>>>>>>>>>>>>>> by working out what a non-aborting H would do and
> >>>>>>>>>>>>>>>>> pretending a different H will do the same thing.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT WHAT A
> >>>>>>>>>>>>>>>> NON-ABORTING SHD WOULD DO. That is what they are
> >>>>>>>>>>>>>>>> supposed to do and that is how they work.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would do, AS
> >>>>>>>>>>>>>>> IS.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs aren't
> >>>>>>>>>>>>>>> actually Halt Deciders.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
> >>>>>>>>>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1,
> >>>>>>>>>>>>>>>> > olcott wrote:
> >>>>>>>>>>>>>>>> >> If a simulating halt decider continues to
> >>>>>>>>>>>>>>>> >> correctly simulate its input until it
> >>>>>>>>>>>>>>>> >> correctly matches a non-halting behavior
> >>>>>>>>>>>>>>>> >> pattern then this SHD is necessarily correct
> >>>>>>>>>>>>>>>> >> when it aborts its simulation and reports
> >>>>>>>>>>>>>>>> >> non-halting.
> >>>>>>>>>>>>>>>> >
> >>>>>>>>>>>>>>>> > Yes, *If* a simulating halt decider continues
> >>>>>>>>>>>>>>>> > to correctly simulate its input until it
> >>>>>>>>>>>>>>>> > *correctly* matches a non- halting behaviour
> >>>>>>>>>>>>>>>> > pattern then this SHD is correct when it
> >>>>>>>>>>>>>>>> > aborts its simulation and reports non-halting.
> >>>>>>>>>>>>>>>> > [*some content snipped to stay focused on this
> >>>>>>>>>>>>>>>> > point*]
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
> >>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
> >>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
> >>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
> >>>>>>>>>>>>>>> behavior of H0 say you can "get away" with it.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the behavior
> >>>>>>>>>>>>>>>> of its input if H never aborted the simulation of its
> >>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
> >>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
> >>>>>>>>>>>>>>> behavior of H1 say you can "get away" with it.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Infinite_Recursion(N);
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
> >>>>>>>>>>>>>>>> never aborted the simulation of its input.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> No! The question isn't what its input would do it H
> >>>>>>>>>>>>>>> never aborted it, since H does abort it, so you are
> >>>>>>>>>>>>>>> asking a question that is a fantasy.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
> >>>>>>>>>>>>>>>>>>>> when-so-ever matching this
> >>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
> >>>>>>>>>>>>>>>>>>>> complete simulation of the
> >>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state of
> >>>>>>>>>>>>>>>>>>>> this simulated input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
> >>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and stops,
> >>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
> >>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence ploughs
> >>>>>>>>>>>>>>>>>>> on regardless.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H only must report on whether or not the correct
> >>>>>>>>>>>>>>>>>> and complete simulation
> >>>>>>>>>>>>>>>>>> of its input would ever reach the final state of
> >>>>>>>>>>>>>>>>>> this simulated input.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> You've talked about simulations so many times you
> >>>>>>>>>>>>>>>>> must realise you're pulling a fast one here. You
> >>>>>>>>>>>>>>>>> claim that P(P) halts. However, you are trying to
> >>>>>>>>>>>>>>>>> run an argument along the following lines:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> A correct and
> >>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return 1, but
> >>>>>>>>>>>>>>> it incorrectly returns 0.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x); // H is
> >>>>>>>>>>>>>>>> replaced with Simulate
> >>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> It SHOULD, but it doesn't
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> "A correct simulation will give the correct answers.
> >>>>>>>>>>>>>>>>> My simulation is correct. My simulation says P(P)
> >>>>>>>>>>>>>>>>> does not halt. Therefore it is acceptable to say
> >>>>>>>>>>>>>>>>> that P(P) does not halt, and that H(P, P) = 0 is an
> >>>>>>>>>>>>>>>>> acceptable answer."
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
> >>>>>>>>>>>>>>> correct answer, or a correct simulation followed by
> >>>>>>>>>>>>>>> sound and valid logic will give the corret answer.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> H does neither of these.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> At times you've explicitly said that the simulation
> >>>>>>>>>>>>>>>>> gives different results from the directly executed
> >>>>>>>>>>>>>>>>> function, but instead of recognising that this
> >>>>>>>>>>>>>>>>> proves your simulator is incorrect, you feel
> >>>>>>>>>>>>>>>>> justified in rejecting the actual results actually
> >>>>>>>>>>>>>>>>> produced by the function in favour of your "correct
> >>>>>>>>>>>>>>>>> simulation".
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so H(P,P)
> >>>>>>>>>>>>>>> is wrong.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Acting like a three year old doesn't make it any more
> >>>>>>>>>>>>>>> right.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>> An intentionally misrepresented proposition that is set
> >>>>>>>>>>>>>> up because it is easier to defeat than an opponent's
> >>>>>>>>>>>>>> real argument.
> >>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Please identify the "Strawman"
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You are a despicable lying scumbag that is so adept at
> >>>>>>>>>>>>>> using the strawman deception that gullible fools accept
> >>>>>>>>>>>>>> your deceitful attempts at rebuttal as correct.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> It is common knowledge that the correct and complete
> >>>>>>>>>>>>>> simulation of a machine description always provides the
> >>>>>>>>>>>>>> actual behavior specified by this machine description.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
> >>>>>>>>>>>>> doesn't do.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD) correctly
> >>>>>>>>>>>>>> performs a partial simulation of its input and the
> >>>>>>>>>>>>>> behavior of this partial simulation correctly matches a
> >>>>>>>>>>>>>> correct non-halting behavior pattern then the SHD halt
> >>>>>>>>>>>>>> decider can correctly report non-halting.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't provided one
> >>>>>>>>>>>>> that you have actually proved is correct for this case.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> A non-halting behavior pattern is correct when-so-ever
> >>>>>>>>>>>>>> matching this behavior pattern proves that the correct
> >>>>>>>>>>>>>> and complete simulation of the input by SHD would never
> >>>>>>>>>>>>>> reach the final state of this simulated input.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and correct
> >>>>>>>>>>>>> simulation of thd input, that is an INVALID definition.
> >>>>>>>>>>>>> Note, you can't change the SHD to be a different machine
> >>>>>>>>>>>>> if doing so changes the code at the input, which
> >>>>>>>>>>>>> includes ALL the code that P calls, not just the code
> >>>>>>>>>>>>> inside the "C function" of P.
> >>>>>>>>>>>>>> H always reports on what the behavior of its input
> >>>>>>>>>>>>>> would be if H was only a simulator and not a
> >>>>>>>>>>>>>> simulating halt decider. All simulating halt deciders
> >>>>>>>>>>>>>> must abort the simulation of inputs that would never
> >>>>>>>>>>>>>> otherwise halt. Here are three examples of that:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> (a) H0(Infinite_Loop)
> >>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
> >>>>>>>>>>>>>> (c) H(P,P)
> >>>>>>>>>>>>> (c) is WRONG.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> So, you admit that H doesn't report the actual behavior
> >>>>>>>>>>>>> of its input, but only the behavior of some other input
> >>>>>>>>>>>>> built on a different H.
> >>>>>>>>>>>>
> >>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
> >>>>>>>>>>>> behavior of its input would be if the SHD performed a
> >>>>>>>>>>>> correct and complete simulation of its input.
> >>>>>>>>>>>
> >>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
> >>>>>>>>>>>
> >>>>>>>>>>> Just by Definition.
> >>>>>>>>>>>
> >>>>>>>>>>> FAIL.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> A mere dogmatic assertion utterly bereft of any supporting
> >>>>>>>>>> reasoning.
> >>>>>>>>>
> >>>>>>>>> IT IS DEFINITION, something you appearently don't understand
> >>>>>>>>> because you are too stupid.
> >>>>>>>>>
> >>>>>>>>> YOU have quoted the soure of this before, but apparently
> >>>>>>>>> your mind can't actually reason or remember.
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
> >>>>>>>>>> A halt decider must always derive its halt status decision
> >>>>>>>>>> on the basis of the actual behavior of the actual input.
> >>>>>>>>>
> >>>>>>>>> Right, and the DEFINITION of the "actual behavior" of the
> >>>>>>>>> "actual input" for an x86 decider is what happens when you
> >>>>>>>>> run that actual input.
> >>>>>>>>>
> >>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
> >>>>>>>>> actual behavor of running P(P)
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
> >>>>>>>>>> It is common knowledge that the correct and complete
> >>>>>>>>>> simulation of a machine description always provides the
> >>>>>>>>>> actual behavior specified by this machine description.
> >>>>>>>>>
> >>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> This means that the actual behavior of the actual input
> >>>>>>>>>> would be the correct and complete simulation of the input
> >>>>>>>>>> to H(P,P) at the exact same point in the execution trace
> >>>>>>>>>> where H is invoked:
> >>>>>>>>>
> >>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
> >>>>>>>>> point is actually a call to H, and is looking for the
> >>>>>>>>> Behavior or H which is supposed to be asking about the
> >>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
> >>>>>>>>> not as executed "At that point in the execution trace", but
> >>>>>>>>> as an actual computation.
> >>>>>>>>>
> >>>>>>>>> I don;t think you know enough about how a program works to
> >>>>>>>>> get into a beginners programming course.
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> void P(ptr x)
> >>>>>>>>>> {
> >>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>
> >>>>>>>> The actual behavior of the actual input is defined as the
> >>>>>>>> behavior of the correct and complete simulation of this
> >>>>>>>> input.
> >>>>>>>
> >>>>>>> Right, BUT, P didn't ask for a correct and complete simulation
> >>>>>>> of the input to H, it wanted a halting decision that
> >>>>>>> corresponded to that behavior, and it whated that in finite
> >>>>>>> time.
> >>>>>>>
> >>>>>>> Thus, replacing the call to H with a simulation of the input
> >>>>>>> to H is not a correct substitution.
> >>>>>>>
> >>>>>>>>
> >>>>>>>> It is the job of H to correctly predict what the behavior of
> >>>>>>>> its input would be if H performed a correct and complete
> >>>>>>>> simulation of this input:
> >>>>>>>
> >>>>>>> Nope, it is to correct predict what the behavior of its input
> >>>>>>> would be if given to a correct and complete simulation of this
> >>>>>>> input.
> >>>>>>>
> >>>>>>> SInce H DOESN'T DO a correct and complete simulation of its
> >>>>>>> input, you statement is nonsence.
> >>>>>>>
> >>>>>>>>
> >>>>>>>> // Never reaches the final state of Infinite_Loop
> >>>>>>>> (a) H0(Infinite_Loop)
> >>>>>>>>
> >>>>>>>> // Never reaches the final state of Infinite_Recursion
> >>>>>>>> (b) H(Infinite_Recursion, 0x777)
> >>>>>>>>
> >>>>>>>> // Never reaches the final state of P
> >>>>>>>> (c) H(P,P)
> >>>>>>>>
> >>>>>>>
> >>>>>>> But doesn't do a correct and complete simulation of its input,
> >>>>>>> so it didn't establish the needed criteria.
> >>>>>>>
> >>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN REPEATED
> >>>>>> MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT HAVE ACTUAL
> >>>>>> BRAIN DAMAGE.
> >>>>>>
> >>>>>> It is the job of H to correctly:
> >>>>>>
> >>>>>> PREDICT
> >>>>>> PREDICT
> >>>>>> PREDICT
> >>>>>> PREDICT
> >>>>>> PREDICT
> >>>>>> PREDICT
> >>>>>> PREDICT
> >>>>>> PREDICT
> >>>>>> what the behavior of its input would be if H performed a
> >>>>>> correct and complete simulation of this input:
> >>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
> >>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
> >>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
> >>>>>> (d) that simulates P(P) that calls a simulated H(P,P)... (on
> >>>>>> and on)
> >>>>>
> >>>>> You've told us numerous times that H does not do this - you have
> >>>>> even explained why it does not do this. So H is not simulating
> >>>>> itself correctly.
> >>>>
> >>>> I could have equally been told many times that cats are a kind of
> >>>> dog, that does not make it true.
> >>>>
> >>>> A simulating halt decider always predicts what the behavior of
> >>>> its input would be if a correct and complete simulation of this
> >>>> input was performed at the exact same place in the execution
> >>>> trace where H is invoked.
> >>>>
> >>>> void P(ptr x)
> >>>> {
> >>>> int Halt_Status = Simulate(x, x);
> >>>> if (Halt_Status)
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
> >>>> (b) that simulates P(P) that calls Simulate(P,P)
> >>>> (c) that simulates P(P) that calls Simulate(P,P)
> >>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and on)
> >>>
> >>> But the fact your H is recursive in nature PREVENTS it from
> >>> performing a "correct and complete simulation of this input". H
> >>> deciding the following is non-halting is an ERROR:
> >>>
> >>> void Px(ptr x)
> >>> {
> >>> (void)H(x, x);
> >>> return;
> >>> }
> >>>
> >>> /Flibble
> >>>
> >>
> >> Flibble does not even know enough to know that when H(Px,Px)
> >> correctly simulates its input that the "return" instruction is
> >> unreachable code by this simulated input.
> >
> > WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
> > that as a halt decider is supposed to return a decision to its
> > caller (Px in this case).
> >
> > /Flibble
> >
>
> In none of these cases will the simulated P(P) ever reach its own
> final state:
>
> void Px(u32 x)
> {
> H(x, x);
> return;
> }
>
> void Py(u32 x)
> {
> Simulate(x, x);
> return;
> }
>
> void Pz(u32 x)
> {
> UTM(x, x);
> return;
> }

On 8/27/2022 5:48 AM, Richard Damon wrote:
> On 8/26/22 11:29 PM, olcott wrote:
>> On 8/26/2022 9:46 PM, Richard Damon wrote:
>>>
>>> On 8/26/22 10:36 PM, olcott wrote:
>>>> On 8/26/2022 8:59 PM, Richard Damon wrote:
>>>>> On 8/26/22 9:44 PM, olcott wrote:
>>>>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>>>>> On 8/26/22 8:13 PM, olcott wrote:
>>>
>>>>>>>> In none of these cases will the simulated P(P) ever reach its
>>>>>>>> own final state:
>>>>>>>>
>>>>>>>> void Px(u32 x)
>>>>>>>> {
>>>>>>>>     H(x, x);
>>>>>>>>     return;
>>>>>>>> }
>>>>>>>
>>>>>>> ^ This will when it is CORRECTLY and COMPLETELY Simulated, since
>>>>>>> H(Px,Px) has been shown to return 0 in finite time.
>>>>>>
>>>>>> So maybe you are as clueless as Flibble.
>>>>>>
>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>
>>>>>> Whether H simulates its input once or allows the recursive
>>>>>> simulations to continue forever there is never a case where
>>>>>> simulated Px ever reaches its final state.
>>>>>>
>>>>>> When H aborts its simulated input it never again simulates a
>>>>>> single instruction of its input thus all recursive emulations are
>>>>>> immediately dead in the water and cannot return to their caller.
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> No, it doesn't. May be you don't know your own code, or you are
>>>>> just a LIAR.
>>>>>
>>>>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at which
>>>>> point the original H(P,P) aborts its simulation and returns 0.
>>>>>
>>>>> THAT is what you code does.
>>>>>
>>>>> That means that a CORRECT and *COMPLETE* simulation of the input to
>>>>> H(P,P) is:
>>>>>
>>>>> Simulator simulated P(P) calling H(P,P).
>>>>> That H(P,P) is simulated to simulate a copy of P(P), and will
>>>>> simulate to it calling H(P,P).
>>>>> That simulated H(P,P) then aborts its simulation and is simulated
>>>>> to return to the P(P) that the outer simulation is simulating.
>>>>>
>>>>> THat simulated P(P) will reach its final state and return.
>>>>>
>>>>> Please point out the error in that description.
>>>>
>>>> The executed H(P,P) simulates P(P) that calls the simulated H(P,P)
>>>> that simulates P(P) that calls the simulated H(P,P)
>>>> that simulates P(P) that calls the simulated H(P,P)
>>>> that simulates P(P) that calls the simulated H(P,P)
>>>> that simulates P(P) that calls the simulated H(P,P)
>>>> until the executed H(P,P) aborts the whole chain causing everything
>>>> else to immediately stop.
>>>>
>>>>
>>>
>>> So, I said that, and the correct and complete simulation of the input
>>> sees that in the simulate call to H(P,P) and then sees the simulate
>>> P(P) reaching its final state.
>>>
>>
>> *You just don't seem to know enough about software engineering*
>> When the outermost executed H(P,P) aborts the simulation of its input
>> all of the simulations immediately stop because it was only the
>> outermost H that was driving them.
>>
>>  From the simulated P's point of view it is just like it hit an
>> abnormal termination core dump divide by zero error. No more steps are
>> simulated.
>>
>
> No, you have your details wrong, at least if you intend to be working on
> the Halting Problem. When H stops its simulation, the SIMULATION stops,
> but the behavior of the simulated P doesn't "stop", it just becomes
> unknown.

You are totally incompetent about this.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 8/27/2022 6:08 AM, Mr Flibble wrote:
> On Fri, 26 Aug 2022 19:13:09 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott wrote:
>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM UTC+1,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 3:50:37 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the input by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches line-by-line the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running: (a) H(P,P) simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P) (d) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your actual H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must always
>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The behaviour of
>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) is that it terminates, or so you
>>>>>>>>>>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
>>>>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a complete
>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>> correctly performs a
>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the behavior
>>>>>>>>>>>>>>>>>>>>>> of this partial
>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
>>>>>>>>>>>>>>>>>>>>> that it doesn't.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has entirely
>>>>>>>>>>>>>>>>>>>> different behavior
>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its actual
>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is P
>>>>>>>>>>>>>>>>>>> and so H must report on what P does. The second
>>>>>>>>>>>>>>>>>>> argument is also P and so specifically H must
>>>>>>>>>>>>>>>>>>> report on what P(P) does. The idea that H(P, P) has
>>>>>>>>>>>>>>>>>>> some sort of "input" which is not P is nonsense.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
>>>>>>>>>>>>>>>>>>>> description always
>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>> H(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that calls
>>>>>>>>>>>>>>>>>>>> a simulated H(P,P) (d) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it into
>>>>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you twice
>>>>>>>>>>>>>>>>>>> in the quotes above alone.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE simulation of
>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and complete
>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is shown by
>>>>>>>>>>>>>>>>>> replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will do simply
>>>>>>>>>>>>>>>>>>> by working out what a non-aborting H would do and
>>>>>>>>>>>>>>>>>>> pretending a different H will do the same thing.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT WHAT A
>>>>>>>>>>>>>>>>>> NON-ABORTING SHD WOULD DO. That is what they are
>>>>>>>>>>>>>>>>>> supposed to do and that is how they work.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would do, AS
>>>>>>>>>>>>>>>>> IS.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs aren't
>>>>>>>>>>>>>>>>> actually Halt Deciders.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1,
>>>>>>>>>>>>>>>>>> > olcott wrote:
>>>>>>>>>>>>>>>>>> >> If a simulating halt decider continues to
>>>>>>>>>>>>>>>>>> >> correctly simulate its input until it
>>>>>>>>>>>>>>>>>> >> correctly matches a non-halting behavior
>>>>>>>>>>>>>>>>>> >> pattern then this SHD is necessarily correct
>>>>>>>>>>>>>>>>>> >> when it aborts its simulation and reports
>>>>>>>>>>>>>>>>>> >> non-halting.
>>>>>>>>>>>>>>>>>> >
>>>>>>>>>>>>>>>>>> > Yes, *If* a simulating halt decider continues
>>>>>>>>>>>>>>>>>> > to correctly simulate its input until it
>>>>>>>>>>>>>>>>>> > *correctly* matches a non- halting behaviour
>>>>>>>>>>>>>>>>>> > pattern then this SHD is correct when it
>>>>>>>>>>>>>>>>>> > aborts its simulation and reports non-halting.
>>>>>>>>>>>>>>>>>> > [*some content snipped to stay focused on this
>>>>>>>>>>>>>>>>>> > point*]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
>>>>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>> behavior of H0 say you can "get away" with it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the behavior
>>>>>>>>>>>>>>>>>> of its input if H never aborted the simulation of its
>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>> behavior of H1 say you can "get away" with it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
>>>>>>>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No! The question isn't what its input would do it H
>>>>>>>>>>>>>>>>> never aborted it, since H does abort it, so you are
>>>>>>>>>>>>>>>>> asking a question that is a fantasy.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state of
>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
>>>>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and stops,
>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence ploughs
>>>>>>>>>>>>>>>>>>>>> on regardless.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the correct
>>>>>>>>>>>>>>>>>>>> and complete simulation
>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final state of
>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You've talked about simulations so many times you
>>>>>>>>>>>>>>>>>>> must realise you're pulling a fast one here. You
>>>>>>>>>>>>>>>>>>> claim that P(P) halts. However, you are trying to
>>>>>>>>>>>>>>>>>>> run an argument along the following lines:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return 1, but
>>>>>>>>>>>>>>>>> it incorrectly returns 0.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x); // H is
>>>>>>>>>>>>>>>>>> replaced with Simulate
>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> "A correct simulation will give the correct answers.
>>>>>>>>>>>>>>>>>>> My simulation is correct. My simulation says P(P)
>>>>>>>>>>>>>>>>>>> does not halt. Therefore it is acceptable to say
>>>>>>>>>>>>>>>>>>> that P(P) does not halt, and that H(P, P) = 0 is an
>>>>>>>>>>>>>>>>>>> acceptable answer."
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
>>>>>>>>>>>>>>>>> correct answer, or a correct simulation followed by
>>>>>>>>>>>>>>>>> sound and valid logic will give the corret answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the simulation
>>>>>>>>>>>>>>>>>>> gives different results from the directly executed
>>>>>>>>>>>>>>>>>>> function, but instead of recognising that this
>>>>>>>>>>>>>>>>>>> proves your simulator is incorrect, you feel
>>>>>>>>>>>>>>>>>>> justified in rejecting the actual results actually
>>>>>>>>>>>>>>>>>>> produced by the function in favour of your "correct
>>>>>>>>>>>>>>>>>>> simulation".
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so H(P,P)
>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it any more
>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is set
>>>>>>>>>>>>>>>> up because it is easier to defeat than an opponent's
>>>>>>>>>>>>>>>> real argument.
>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so adept at
>>>>>>>>>>>>>>>> using the strawman deception that gullible fools accept
>>>>>>>>>>>>>>>> your deceitful attempts at rebuttal as correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
>>>>>>>>>>>>>>> doesn't do.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD) correctly
>>>>>>>>>>>>>>>> performs a partial simulation of its input and the
>>>>>>>>>>>>>>>> behavior of this partial simulation correctly matches a
>>>>>>>>>>>>>>>> correct non-halting behavior pattern then the SHD halt
>>>>>>>>>>>>>>>> decider can correctly report non-halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't provided one
>>>>>>>>>>>>>>> that you have actually proved is correct for this case.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct when-so-ever
>>>>>>>>>>>>>>>> matching this behavior pattern proves that the correct
>>>>>>>>>>>>>>>> and complete simulation of the input by SHD would never
>>>>>>>>>>>>>>>> reach the final state of this simulated input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and correct
>>>>>>>>>>>>>>> simulation of thd input, that is an INVALID definition.
>>>>>>>>>>>>>>> Note, you can't change the SHD to be a different machine
>>>>>>>>>>>>>>> if doing so changes the code at the input, which
>>>>>>>>>>>>>>> includes ALL the code that P calls, not just the code
>>>>>>>>>>>>>>> inside the "C function" of P.
>>>>>>>>>>>>>>>> H always reports on what the behavior of its input
>>>>>>>>>>>>>>>> would be if H was only a simulator and not a
>>>>>>>>>>>>>>>> simulating halt decider. All simulating halt deciders
>>>>>>>>>>>>>>>> must abort the simulation of inputs that would never
>>>>>>>>>>>>>>>> otherwise halt. Here are three examples of that:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual behavior
>>>>>>>>>>>>>>> of its input, but only the behavior of some other input
>>>>>>>>>>>>>>> built on a different H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
>>>>>>>>>>>>>> behavior of its input would be if the SHD performed a
>>>>>>>>>>>>>> correct and complete simulation of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any supporting
>>>>>>>>>>>> reasoning.
>>>>>>>>>>>
>>>>>>>>>>> IT IS DEFINITION, something you appearently don't understand
>>>>>>>>>>> because you are too stupid.
>>>>>>>>>>>
>>>>>>>>>>> YOU have quoted the soure of this before, but apparently
>>>>>>>>>>> your mind can't actually reason or remember.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>> A halt decider must always derive its halt status decision
>>>>>>>>>>>> on the basis of the actual behavior of the actual input.
>>>>>>>>>>>
>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior" of the
>>>>>>>>>>> "actual input" for an x86 decider is what happens when you
>>>>>>>>>>> run that actual input.
>>>>>>>>>>>
>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
>>>>>>>>>>> actual behavor of running P(P)
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>
>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> This means that the actual behavior of the actual input
>>>>>>>>>>>> would be the correct and complete simulation of the input
>>>>>>>>>>>> to H(P,P) at the exact same point in the execution trace
>>>>>>>>>>>> where H is invoked:
>>>>>>>>>>>
>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
>>>>>>>>>>> point is actually a call to H, and is looking for the
>>>>>>>>>>> Behavior or H which is supposed to be asking about the
>>>>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
>>>>>>>>>>> not as executed "At that point in the execution trace", but
>>>>>>>>>>> as an actual computation.
>>>>>>>>>>>
>>>>>>>>>>> I don;t think you know enough about how a program works to
>>>>>>>>>>> get into a beginners programming course.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>>>
>>>>>>>>>> The actual behavior of the actual input is defined as the
>>>>>>>>>> behavior of the correct and complete simulation of this
>>>>>>>>>> input.
>>>>>>>>>
>>>>>>>>> Right, BUT, P didn't ask for a correct and complete simulation
>>>>>>>>> of the input to H, it wanted a halting decision that
>>>>>>>>> corresponded to that behavior, and it whated that in finite
>>>>>>>>> time.
>>>>>>>>>
>>>>>>>>> Thus, replacing the call to H with a simulation of the input
>>>>>>>>> to H is not a correct substitution.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is the job of H to correctly predict what the behavior of
>>>>>>>>>> its input would be if H performed a correct and complete
>>>>>>>>>> simulation of this input:
>>>>>>>>>
>>>>>>>>> Nope, it is to correct predict what the behavior of its input
>>>>>>>>> would be if given to a correct and complete simulation of this
>>>>>>>>> input.
>>>>>>>>>
>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation of its
>>>>>>>>> input, you statement is nonsence.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>
>>>>>>>>>> // Never reaches the final state of Infinite_Recursion
>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>
>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But doesn't do a correct and complete simulation of its input,
>>>>>>>>> so it didn't establish the needed criteria.
>>>>>>>>>
>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN REPEATED
>>>>>>>> MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT HAVE ACTUAL
>>>>>>>> BRAIN DAMAGE.
>>>>>>>>
>>>>>>>> It is the job of H to correctly:
>>>>>>>>
>>>>>>>> PREDICT
>>>>>>>> PREDICT
>>>>>>>> PREDICT
>>>>>>>> PREDICT
>>>>>>>> PREDICT
>>>>>>>> PREDICT
>>>>>>>> PREDICT
>>>>>>>> PREDICT
>>>>>>>> what the behavior of its input would be if H performed a
>>>>>>>> correct and complete simulation of this input:
>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)... (on
>>>>>>>> and on)
>>>>>>>
>>>>>>> You've told us numerous times that H does not do this - you have
>>>>>>> even explained why it does not do this. So H is not simulating
>>>>>>> itself correctly.
>>>>>>
>>>>>> I could have equally been told many times that cats are a kind of
>>>>>> dog, that does not make it true.
>>>>>>
>>>>>> A simulating halt decider always predicts what the behavior of
>>>>>> its input would be if a correct and complete simulation of this
>>>>>> input was performed at the exact same place in the execution
>>>>>> trace where H is invoked.
>>>>>>
>>>>>> void P(ptr x)
>>>>>> {
>>>>>> int Halt_Status = Simulate(x, x);
>>>>>> if (Halt_Status)
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and on)
>>>>>
>>>>> But the fact your H is recursive in nature PREVENTS it from
>>>>> performing a "correct and complete simulation of this input". H
>>>>> deciding the following is non-halting is an ERROR:
>>>>>
>>>>> void Px(ptr x)
>>>>> {
>>>>> (void)H(x, x);
>>>>> return;
>>>>> }
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Flibble does not even know enough to know that when H(Px,Px)
>>>> correctly simulates its input that the "return" instruction is
>>>> unreachable code by this simulated input.
>>>
>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
>>> that as a halt decider is supposed to return a decision to its
>>> caller (Px in this case).
>>>
>>> /Flibble
>>>
>>
>> In none of these cases will the simulated P(P) ever reach its own
>> final state:
>>
>> void Px(u32 x)
>> {
>> H(x, x);
>> return;
>> }
>>
>> void Py(u32 x)
>> {
>> Simulate(x, x);
>> return;
>> }
>>
>> void Pz(u32 x)
>> {
>> UTM(x, x);
>> return;
>> }
>
> Error by non-equivalence: a halt decider (i.e. H) is supposed to return
> a result to its caller in finite time.
>
> /Flibble
>

On 8/27/22 10:45 AM, olcott wrote:
> On 8/27/2022 5:48 AM, Richard Damon wrote:
>> On 8/26/22 11:29 PM, olcott wrote:
>>> On 8/26/2022 9:46 PM, Richard Damon wrote:
>>>>
>>>> On 8/26/22 10:36 PM, olcott wrote:
>>>>> On 8/26/2022 8:59 PM, Richard Damon wrote:
>>>>>> On 8/26/22 9:44 PM, olcott wrote:
>>>>>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>>>>>> On 8/26/22 8:13 PM, olcott wrote:
>>>>
>>>>>>>>> In none of these cases will the simulated P(P) ever reach its
>>>>>>>>> own final state:
>>>>>>>>>
>>>>>>>>> void Px(u32 x)
>>>>>>>>> {
>>>>>>>>>     H(x, x);
>>>>>>>>>     return;
>>>>>>>>> }
>>>>>>>>
>>>>>>>> ^ This will when it is CORRECTLY and COMPLETELY Simulated, since
>>>>>>>> H(Px,Px) has been shown to return 0 in finite time.
>>>>>>>
>>>>>>> So maybe you are as clueless as Flibble.
>>>>>>>
>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>
>>>>>>> Whether H simulates its input once or allows the recursive
>>>>>>> simulations to continue forever there is never a case where
>>>>>>> simulated Px ever reaches its final state.
>>>>>>>
>>>>>>> When H aborts its simulated input it never again simulates a
>>>>>>> single instruction of its input thus all recursive emulations are
>>>>>>> immediately dead in the water and cannot return to their caller.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> No, it doesn't. May be you don't know your own code, or you are
>>>>>> just a LIAR.
>>>>>>
>>>>>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at which
>>>>>> point the original H(P,P) aborts its simulation and returns 0.
>>>>>>
>>>>>> THAT is what you code does.
>>>>>>
>>>>>> That means that a CORRECT and *COMPLETE* simulation of the input
>>>>>> to H(P,P) is:
>>>>>>
>>>>>> Simulator simulated P(P) calling H(P,P).
>>>>>> That H(P,P) is simulated to simulate a copy of P(P), and will
>>>>>> simulate to it calling H(P,P).
>>>>>> That simulated H(P,P) then aborts its simulation and is simulated
>>>>>> to return to the P(P) that the outer simulation is simulating.
>>>>>>
>>>>>> THat simulated P(P) will reach its final state and return.
>>>>>>
>>>>>> Please point out the error in that description.
>>>>>
>>>>> The executed H(P,P) simulates P(P) that calls the simulated H(P,P)
>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>> until the executed H(P,P) aborts the whole chain causing everything
>>>>> else to immediately stop.
>>>>>
>>>>>
>>>>
>>>> So, I said that, and the correct and complete simulation of the
>>>> input sees that in the simulate call to H(P,P) and then sees the
>>>> simulate P(P) reaching its final state.
>>>>
>>>
>>> *You just don't seem to know enough about software engineering*
>>> When the outermost executed H(P,P) aborts the simulation of its input
>>> all of the simulations immediately stop because it was only the
>>> outermost H that was driving them.
>>>
>>>  From the simulated P's point of view it is just like it hit an
>>> abnormal termination core dump divide by zero error. No more steps
>>> are simulated.
>>>
>>
>> No, you have your details wrong, at least if you intend to be working
>> on the Halting Problem. When H stops its simulation, the SIMULATION
>> stops, but the behavior of the simulated P doesn't "stop", it just
>> becomes unknown.
>
> You are totally incompetent about this.
>
>

Then you can point out an actual error, or are YOU the incompetent one?

Your problem is fundamentally, you don't know the actual meaning of the
words you are trying to use, as they apply to the theory you claim to be
talking about.

The ACTUAL BEHAVIOR of the ACTUAL INPUT to H(P,P) is Halting.

Thus H(P,P) Needs, to be correct, to return 1, but it returns 0.

The is no wiggle room in that statement.

On 8/27/22 10:48 AM, olcott wrote:
> On 8/27/2022 6:08 AM, Mr Flibble wrote:
>> On Fri, 26 Aug 2022 19:13:09 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott wrote:
>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM UTC+1,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 3:50:37 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the input by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches line-by-line the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running: (a) H(P,P) simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P) (d) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your actual H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The behaviour of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) is that it terminates, or so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
>>>>>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a complete
>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>> correctly performs a
>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the behavior
>>>>>>>>>>>>>>>>>>>>>>> of this partial
>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
>>>>>>>>>>>>>>>>>>>>>> that it doesn't.
>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has entirely
>>>>>>>>>>>>>>>>>>>>> different behavior
>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its actual
>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is P
>>>>>>>>>>>>>>>>>>>> and so H must report on what P does. The second
>>>>>>>>>>>>>>>>>>>> argument is also P and so specifically H must
>>>>>>>>>>>>>>>>>>>> report on what P(P) does. The idea that H(P, P) has
>>>>>>>>>>>>>>>>>>>> some sort of "input" which is not P is nonsense.
>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
>>>>>>>>>>>>>>>>>>>>> description always
>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>> H(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that calls
>>>>>>>>>>>>>>>>>>>>> a simulated H(P,P) (d) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it into
>>>>>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you twice
>>>>>>>>>>>>>>>>>>>> in the quotes above alone.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE simulation of
>>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and complete
>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is shown by
>>>>>>>>>>>>>>>>>>> replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>        Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will do simply
>>>>>>>>>>>>>>>>>>>> by working out what a non-aborting H would do and
>>>>>>>>>>>>>>>>>>>> pretending a different H will do the same thing.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT WHAT A
>>>>>>>>>>>>>>>>>>> NON-ABORTING SHD WOULD DO. That is what they are
>>>>>>>>>>>>>>>>>>> supposed to do and that is how they work.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would do, AS
>>>>>>>>>>>>>>>>>> IS.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs aren't
>>>>>>>>>>>>>>>>>> actually Halt Deciders.
>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>      > On Monday, July 25, 2022 at 12:10:34 AM UTC+1,
>>>>>>>>>>>>>>>>>>>      > olcott wrote:
>>>>>>>>>>>>>>>>>>>      >> If a simulating halt decider continues to
>>>>>>>>>>>>>>>>>>>      >> correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>      >> correctly matches a non-halting behavior
>>>>>>>>>>>>>>>>>>>      >> pattern then this SHD is necessarily correct
>>>>>>>>>>>>>>>>>>>      >> when it aborts its simulation and reports
>>>>>>>>>>>>>>>>>>>      >> non-halting.
>>>>>>>>>>>>>>>>>>>      >
>>>>>>>>>>>>>>>>>>>      > Yes, *If* a simulating halt decider continues
>>>>>>>>>>>>>>>>>>>      > to correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>      > *correctly* matches a non- halting behaviour
>>>>>>>>>>>>>>>>>>>      > pattern then this SHD is correct when it
>>>>>>>>>>>>>>>>>>>      > aborts its simulation and reports non-halting.
>>>>>>>>>>>>>>>>>>>      > [*some content snipped to stay focused on this
>>>>>>>>>>>>>>>>>>>      > point*]
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
>>>>>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>> behavior of H0 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>        HERE: goto HERE;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the behavior
>>>>>>>>>>>>>>>>>>> of its input if H never aborted the simulation of its
>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>> behavior of H1 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>        Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
>>>>>>>>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No! The question isn't what its input would do it H
>>>>>>>>>>>>>>>>>> never aborted it, since H does abort it, so you are
>>>>>>>>>>>>>>>>>> asking a question that is a fantasy.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state of
>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
>>>>>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and stops,
>>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
>>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence ploughs
>>>>>>>>>>>>>>>>>>>>>> on regardless.
>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the correct
>>>>>>>>>>>>>>>>>>>>> and complete simulation
>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final state of
>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many times you
>>>>>>>>>>>>>>>>>>>> must realise you're pulling a fast one here. You
>>>>>>>>>>>>>>>>>>>> claim that P(P) halts. However, you are trying to
>>>>>>>>>>>>>>>>>>>> run an argument along the following lines:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return 1, but
>>>>>>>>>>>>>>>>>> it incorrectly returns 0.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x); // H is
>>>>>>>>>>>>>>>>>>> replaced with Simulate
>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the correct answers.
>>>>>>>>>>>>>>>>>>>> My simulation is correct. My simulation says P(P)
>>>>>>>>>>>>>>>>>>>> does not halt. Therefore it is acceptable to say
>>>>>>>>>>>>>>>>>>>> that P(P) does not halt, and that H(P, P) = 0 is an
>>>>>>>>>>>>>>>>>>>> acceptable answer."
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
>>>>>>>>>>>>>>>>>> correct answer, or a correct simulation followed by
>>>>>>>>>>>>>>>>>> sound and valid logic will give the corret answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the simulation
>>>>>>>>>>>>>>>>>>>> gives different results from the directly executed
>>>>>>>>>>>>>>>>>>>> function, but instead of recognising that this
>>>>>>>>>>>>>>>>>>>> proves your simulator is incorrect, you feel
>>>>>>>>>>>>>>>>>>>> justified in rejecting the actual results actually
>>>>>>>>>>>>>>>>>>>> produced by the function in favour of your "correct
>>>>>>>>>>>>>>>>>>>> simulation".
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so H(P,P)
>>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it any more
>>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is set
>>>>>>>>>>>>>>>>> up because it is easier to defeat than an opponent's
>>>>>>>>>>>>>>>>> real argument.
>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so adept at
>>>>>>>>>>>>>>>>> using the strawman deception that gullible fools accept
>>>>>>>>>>>>>>>>> your deceitful attempts at rebuttal as correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
>>>>>>>>>>>>>>>> doesn't do.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD) correctly
>>>>>>>>>>>>>>>>> performs a partial simulation of its input and the
>>>>>>>>>>>>>>>>> behavior of this partial simulation correctly matches a
>>>>>>>>>>>>>>>>> correct non-halting behavior pattern then the SHD halt
>>>>>>>>>>>>>>>>> decider can correctly report non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't provided one
>>>>>>>>>>>>>>>> that you have actually proved is correct for this case.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct when-so-ever
>>>>>>>>>>>>>>>>> matching this behavior pattern proves that the correct
>>>>>>>>>>>>>>>>> and complete simulation of the input by SHD would never
>>>>>>>>>>>>>>>>> reach the final state of this simulated input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and correct
>>>>>>>>>>>>>>>> simulation of thd input, that is an INVALID definition.
>>>>>>>>>>>>>>>> Note, you can't change the SHD to be a different machine
>>>>>>>>>>>>>>>> if doing so changes the code at the input, which
>>>>>>>>>>>>>>>> includes ALL the code that P calls, not just the code
>>>>>>>>>>>>>>>> inside the "C function" of P.
>>>>>>>>>>>>>>>>> H always reports on what the behavior of its input
>>>>>>>>>>>>>>>>> would be if H was only a simulator and not a
>>>>>>>>>>>>>>>>> simulating halt decider. All simulating halt deciders
>>>>>>>>>>>>>>>>> must abort the simulation of inputs that would never
>>>>>>>>>>>>>>>>> otherwise halt. Here are three examples of that:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual behavior
>>>>>>>>>>>>>>>> of its input, but only the behavior of some other input
>>>>>>>>>>>>>>>> built on a different H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
>>>>>>>>>>>>>>> behavior of its input would be if the SHD performed a
>>>>>>>>>>>>>>> correct and complete simulation of its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any supporting
>>>>>>>>>>>>> reasoning.
>>>>>>>>>>>>
>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't understand
>>>>>>>>>>>> because you are too stupid.
>>>>>>>>>>>>
>>>>>>>>>>>> YOU have quoted the soure of this before, but apparently
>>>>>>>>>>>> your mind can't actually reason or remember.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>>> A halt decider must always derive its halt status decision
>>>>>>>>>>>>> on the basis of the actual behavior of the actual input.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior" of the
>>>>>>>>>>>> "actual input" for an x86 decider is what happens when you
>>>>>>>>>>>> run that actual input.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
>>>>>>>>>>>> actual behavor of running P(P)
>>>>>>>>>>>>>
>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
>>>>>>>>>>>>>
>>>>>>>>>>>>> This means that the actual behavior of the actual input
>>>>>>>>>>>>> would be the correct and complete simulation of the input
>>>>>>>>>>>>> to H(P,P) at the exact same point in the execution trace
>>>>>>>>>>>>> where H is invoked:
>>>>>>>>>>>>
>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
>>>>>>>>>>>> point is actually a call to H, and is looking for the
>>>>>>>>>>>> Behavior or H which is supposed to be asking about the
>>>>>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
>>>>>>>>>>>> not as executed "At that point in the execution trace", but
>>>>>>>>>>>> as an actual computation.
>>>>>>>>>>>>
>>>>>>>>>>>> I don;t think you know enough about how a program works to
>>>>>>>>>>>> get into a beginners programming course.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>> The actual behavior of the actual input is defined as the
>>>>>>>>>>> behavior of the correct and complete simulation of this
>>>>>>>>>>> input.
>>>>>>>>>>
>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete simulation
>>>>>>>>>> of the input to H, it wanted a halting decision that
>>>>>>>>>> corresponded to that behavior, and it whated that in finite
>>>>>>>>>> time.
>>>>>>>>>>
>>>>>>>>>> Thus, replacing the call to H with a simulation of the input
>>>>>>>>>> to H is not a correct substitution.
>>>>>>>>>>>
>>>>>>>>>>> It is the job of H to correctly predict what the behavior of
>>>>>>>>>>> its input would be if H performed a correct and complete
>>>>>>>>>>> simulation of this input:
>>>>>>>>>>
>>>>>>>>>> Nope, it is to correct predict what the behavior of its input
>>>>>>>>>> would be if given to a correct and complete simulation of this
>>>>>>>>>> input.
>>>>>>>>>>
>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation of its
>>>>>>>>>> input, you statement is nonsence.
>>>>>>>>>>>
>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>
>>>>>>>>>>> // Never reaches the final state of Infinite_Recursion
>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>
>>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>
>>>>>>>>>> But doesn't do a correct and complete simulation of its input,
>>>>>>>>>> so it didn't establish the needed criteria.
>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN REPEATED
>>>>>>>>> MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT HAVE ACTUAL
>>>>>>>>> BRAIN DAMAGE.
>>>>>>>>>
>>>>>>>>> It is the job of H to correctly:
>>>>>>>>>
>>>>>>>>> PREDICT
>>>>>>>>> PREDICT
>>>>>>>>> PREDICT
>>>>>>>>> PREDICT
>>>>>>>>> PREDICT
>>>>>>>>> PREDICT
>>>>>>>>> PREDICT
>>>>>>>>> PREDICT
>>>>>>>>> what the behavior of its input would be if H performed a
>>>>>>>>> correct and complete simulation of this input:
>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)... (on
>>>>>>>>> and on)
>>>>>>>>
>>>>>>>> You've told us numerous times that H does not do this - you have
>>>>>>>> even explained why it does not do this. So H is not simulating
>>>>>>>> itself correctly.
>>>>>>>
>>>>>>> I could have equally been told many times that cats are a kind of
>>>>>>> dog, that does not make it true.
>>>>>>>
>>>>>>> A simulating halt decider always predicts what the behavior of
>>>>>>> its input would be if a correct and complete simulation of this
>>>>>>> input was performed at the exact same place in the execution
>>>>>>> trace where H is invoked.
>>>>>>>
>>>>>>> void P(ptr x)
>>>>>>> {
>>>>>>>       int Halt_Status = Simulate(x, x);
>>>>>>>       if (Halt_Status)
>>>>>>>         HERE: goto HERE;
>>>>>>>       return;
>>>>>>> }
>>>>>>>
>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and on)
>>>>>>
>>>>>> But the fact your H is recursive in nature PREVENTS it from
>>>>>> performing a "correct and complete simulation of this input".  H
>>>>>> deciding the following is non-halting is an ERROR:
>>>>>>
>>>>>> void Px(ptr x)
>>>>>> {
>>>>>>      (void)H(x, x);
>>>>>>      return;
>>>>>> }
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> Flibble does not even know enough to know that when H(Px,Px)
>>>>> correctly simulates its input that the "return" instruction is
>>>>> unreachable code by this simulated input.
>>>>
>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
>>>> that as a halt decider is supposed to return a decision to its
>>>> caller (Px in this case).
>>>>
>>>> /Flibble
>>>
>>> In none of these cases will the simulated P(P) ever reach its own
>>> final state:
>>>
>>> void Px(u32 x)
>>> {
>>>      H(x, x);
>>>      return;
>>> }
>>>
>>> void Py(u32 x)
>>> {
>>>      Simulate(x, x);
>>>      return;
>>> }
>>>
>>> void Pz(u32 x)
>>> {
>>>      UTM(x, x);
>>>      return;
>>> }
>>
>> Error by non-equivalence: a halt decider (i.e. H) is supposed to return
>> a result to its caller in finite time.
>>
>> /Flibble
>>
>
> The outermost H returns to its caller, the first inner H is aborted
> before it is even invoked.
>

On Sat, 27 Aug 2022 09:48:21 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/27/2022 6:08 AM, Mr Flibble wrote:
> > On Fri, 26 Aug 2022 19:13:09 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/26/2022 6:49 PM, Mr Flibble wrote:
> >>> On Fri, 26 Aug 2022 16:43:15 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
> >>>>> On Fri, 26 Aug 2022 16:06:19 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
> >>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott wrote:
> >>>>>>>
> >>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
> >>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
> >>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
> >>>>>>>>>>>
> >>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
> >>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
> >>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM UTC+1,
> >>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM
> >>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
> >>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
> >>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 3:50:37
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution trace
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the simulation of the input by
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches line-by-line the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input never
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and stops
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running: (a) H(P,P) simulates P(P) that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P) (d)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that simulates P(P) that calls a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P)...
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> 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]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your actual
> >>>>>>>>>>>>>>>>>>>>>>>>>>> H.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must always
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
> >>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The behaviour
> >>>>>>>>>>>>>>>>>>>>>>>>>>> of P(P) is that it terminates, or so you
> >>>>>>>>>>>>>>>>>>>>>>>>>>> claim.
> >>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
> >>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its
> >>>>>>>>>>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
> >>>>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
> >>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of a
> >>>>>>>>>>>>>>>>>>>>>>>> machine description always
> >>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by
> >>>>>>>>>>>>>>>>>>>>>>>> this machine description.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a
> >>>>>>>>>>>>>>>>>>>>>>> complete simulation.
> >>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
> >>>>>>>>>>>>>>>>>>>>>> correctly performs a
> >>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the
> >>>>>>>>>>>>>>>>>>>>>> behavior of this partial
> >>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
> >>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
> >>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
> >>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
> >>>>>>>>>>>>>>>>>>>>> that it doesn't.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
> >>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has
> >>>>>>>>>>>>>>>>>>>> entirely different behavior
> >>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its actual
> >>>>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is P
> >>>>>>>>>>>>>>>>>>> and so H must report on what P does. The second
> >>>>>>>>>>>>>>>>>>> argument is also P and so specifically H must
> >>>>>>>>>>>>>>>>>>> report on what P(P) does. The idea that H(P, P)
> >>>>>>>>>>>>>>>>>>> has some sort of "input" which is not P is
> >>>>>>>>>>>>>>>>>>> nonsense.
> >>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
> >>>>>>>>>>>>>>>>>>>> description always
> >>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
> >>>>>>>>>>>>>>>>>>>> machine description.
> >>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
> >>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
> >>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated
> >>>>>>>>>>>>>>>>>>>> H(P,P) (b) that simulates P(P) that calls a
> >>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that
> >>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P) (d) that simulates P(P)
> >>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P)...
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> You know this is not true, and putting it into
> >>>>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you
> >>>>>>>>>>>>>>>>>>> twice in the quotes above alone.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE simulation of
> >>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and
> >>>>>>>>>>>>>>>>>> complete simulation of the input to H(P,P) is
> >>>>>>>>>>>>>>>>>> shown by replacing H() with Simulate().
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will do
> >>>>>>>>>>>>>>>>>>> simply by working out what a non-aborting H would
> >>>>>>>>>>>>>>>>>>> do and pretending a different H will do the same
> >>>>>>>>>>>>>>>>>>> thing.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT
> >>>>>>>>>>>>>>>>>> WHAT A NON-ABORTING SHD WOULD DO. That is what
> >>>>>>>>>>>>>>>>>> they are supposed to do and that is how they work.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would do,
> >>>>>>>>>>>>>>>>> AS IS.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs
> >>>>>>>>>>>>>>>>> aren't actually Halt Deciders.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM
> >>>>>>>>>>>>>>>>>> > UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>> >> If a simulating halt decider continues to
> >>>>>>>>>>>>>>>>>> >> correctly simulate its input until it
> >>>>>>>>>>>>>>>>>> >> correctly matches a non-halting behavior
> >>>>>>>>>>>>>>>>>> >> pattern then this SHD is necessarily
> >>>>>>>>>>>>>>>>>> >> correct when it aborts its simulation and
> >>>>>>>>>>>>>>>>>> >> reports non-halting.
> >>>>>>>>>>>>>>>>>> >
> >>>>>>>>>>>>>>>>>> > Yes, *If* a simulating halt decider
> >>>>>>>>>>>>>>>>>> > continues to correctly simulate its input
> >>>>>>>>>>>>>>>>>> > until it *correctly* matches a non- halting
> >>>>>>>>>>>>>>>>>> > behaviour pattern then this SHD is correct
> >>>>>>>>>>>>>>>>>> > when it aborts its simulation and reports
> >>>>>>>>>>>>>>>>>> > non-halting. [*some content snipped to stay
> >>>>>>>>>>>>>>>>>> > focused on this point*]
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
> >>>>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
> >>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
> >>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
> >>>>>>>>>>>>>>>>> behavior of H0 say you can "get away" with it.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the
> >>>>>>>>>>>>>>>>>> behavior of its input if H never aborted the
> >>>>>>>>>>>>>>>>>> simulation of its input.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
> >>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
> >>>>>>>>>>>>>>>>> behavior of H1 say you can "get away" with it.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
> >>>>>>>>>>>>>>>>>> never aborted the simulation of its input.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No! The question isn't what its input would do it H
> >>>>>>>>>>>>>>>>> never aborted it, since H does abort it, so you are
> >>>>>>>>>>>>>>>>> asking a question that is a fantasy.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
> >>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
> >>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
> >>>>>>>>>>>>>>>>>>>>>> complete simulation of the
> >>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state
> >>>>>>>>>>>>>>>>>>>>>> of this simulated input.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
> >>>>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and stops,
> >>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
> >>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence ploughs
> >>>>>>>>>>>>>>>>>>>>> on regardless.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> H only must report on whether or not the correct
> >>>>>>>>>>>>>>>>>>>> and complete simulation
> >>>>>>>>>>>>>>>>>>>> of its input would ever reach the final state of
> >>>>>>>>>>>>>>>>>>>> this simulated input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> You've talked about simulations so many times you
> >>>>>>>>>>>>>>>>>>> must realise you're pulling a fast one here. You
> >>>>>>>>>>>>>>>>>>> claim that P(P) halts. However, you are trying to
> >>>>>>>>>>>>>>>>>>> run an argument along the following lines:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> A correct and
> >>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return 1,
> >>>>>>>>>>>>>>>>> but it incorrectly returns 0.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x); // H is
> >>>>>>>>>>>>>>>>>> replaced with Simulate
> >>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
> >>>>>>>>>>>>>>>>>> SIMULATION
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> "A correct simulation will give the correct
> >>>>>>>>>>>>>>>>>>> answers. My simulation is correct. My simulation
> >>>>>>>>>>>>>>>>>>> says P(P) does not halt. Therefore it is
> >>>>>>>>>>>>>>>>>>> acceptable to say that P(P) does not halt, and
> >>>>>>>>>>>>>>>>>>> that H(P, P) = 0 is an acceptable answer."
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
> >>>>>>>>>>>>>>>>> correct answer, or a correct simulation followed by
> >>>>>>>>>>>>>>>>> sound and valid logic will give the corret answer.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> H does neither of these.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> At times you've explicitly said that the
> >>>>>>>>>>>>>>>>>>> simulation gives different results from the
> >>>>>>>>>>>>>>>>>>> directly executed function, but instead of
> >>>>>>>>>>>>>>>>>>> recognising that this proves your simulator is
> >>>>>>>>>>>>>>>>>>> incorrect, you feel justified in rejecting the
> >>>>>>>>>>>>>>>>>>> actual results actually produced by the function
> >>>>>>>>>>>>>>>>>>> in favour of your "correct simulation".
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so H(P,P)
> >>>>>>>>>>>>>>>>> is wrong.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it any
> >>>>>>>>>>>>>>>>> more right.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is
> >>>>>>>>>>>>>>>> set up because it is easier to defeat than an
> >>>>>>>>>>>>>>>> opponent's real argument.
> >>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Please identify the "Strawman"
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so adept
> >>>>>>>>>>>>>>>> at using the strawman deception that gullible fools
> >>>>>>>>>>>>>>>> accept your deceitful attempts at rebuttal as
> >>>>>>>>>>>>>>>> correct.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
> >>>>>>>>>>>>>>>> simulation of a machine description always provides
> >>>>>>>>>>>>>>>> the actual behavior specified by this machine
> >>>>>>>>>>>>>>>> description.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
> >>>>>>>>>>>>>>> doesn't do.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
> >>>>>>>>>>>>>>>> correctly performs a partial simulation of its input
> >>>>>>>>>>>>>>>> and the behavior of this partial simulation
> >>>>>>>>>>>>>>>> correctly matches a correct non-halting behavior
> >>>>>>>>>>>>>>>> pattern then the SHD halt decider can correctly
> >>>>>>>>>>>>>>>> report non-halting.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't provided
> >>>>>>>>>>>>>>> one that you have actually proved is correct for this
> >>>>>>>>>>>>>>> case.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
> >>>>>>>>>>>>>>>> when-so-ever matching this behavior pattern proves
> >>>>>>>>>>>>>>>> that the correct and complete simulation of the
> >>>>>>>>>>>>>>>> input by SHD would never reach the final state of
> >>>>>>>>>>>>>>>> this simulated input.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and correct
> >>>>>>>>>>>>>>> simulation of thd input, that is an INVALID
> >>>>>>>>>>>>>>> definition. Note, you can't change the SHD to be a
> >>>>>>>>>>>>>>> different machine if doing so changes the code at the
> >>>>>>>>>>>>>>> input, which includes ALL the code that P calls, not
> >>>>>>>>>>>>>>> just the code inside the "C function" of P.
> >>>>>>>>>>>>>>>> H always reports on what the behavior of its input
> >>>>>>>>>>>>>>>> would be if H was only a simulator and not a
> >>>>>>>>>>>>>>>> simulating halt decider. All simulating halt deciders
> >>>>>>>>>>>>>>>> must abort the simulation of inputs that would never
> >>>>>>>>>>>>>>>> otherwise halt. Here are three examples of that:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
> >>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
> >>>>>>>>>>>>>>>> (c) H(P,P)
> >>>>>>>>>>>>>>> (c) is WRONG.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> So, you admit that H doesn't report the actual
> >>>>>>>>>>>>>>> behavior of its input, but only the behavior of some
> >>>>>>>>>>>>>>> other input built on a different H.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
> >>>>>>>>>>>>>> behavior of its input would be if the SHD performed a
> >>>>>>>>>>>>>> correct and complete simulation of its input.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Just by Definition.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> FAIL.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any
> >>>>>>>>>>>> supporting reasoning.
> >>>>>>>>>>>
> >>>>>>>>>>> IT IS DEFINITION, something you appearently don't
> >>>>>>>>>>> understand because you are too stupid.
> >>>>>>>>>>>
> >>>>>>>>>>> YOU have quoted the soure of this before, but apparently
> >>>>>>>>>>> your mind can't actually reason or remember.
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
> >>>>>>>>>>>> A halt decider must always derive its halt status
> >>>>>>>>>>>> decision on the basis of the actual behavior of the
> >>>>>>>>>>>> actual input.
> >>>>>>>>>>>
> >>>>>>>>>>> Right, and the DEFINITION of the "actual behavior" of the
> >>>>>>>>>>> "actual input" for an x86 decider is what happens when you
> >>>>>>>>>>> run that actual input.
> >>>>>>>>>>>
> >>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
> >>>>>>>>>>> actual behavor of running P(P)
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
> >>>>>>>>>>>> It is common knowledge that the correct and complete
> >>>>>>>>>>>> simulation of a machine description always provides the
> >>>>>>>>>>>> actual behavior specified by this machine description.
> >>>>>>>>>>>
> >>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> This means that the actual behavior of the actual input
> >>>>>>>>>>>> would be the correct and complete simulation of the input
> >>>>>>>>>>>> to H(P,P) at the exact same point in the execution trace
> >>>>>>>>>>>> where H is invoked:
> >>>>>>>>>>>
> >>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
> >>>>>>>>>>> point is actually a call to H, and is looking for the
> >>>>>>>>>>> Behavior or H which is supposed to be asking about the
> >>>>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
> >>>>>>>>>>> not as executed "At that point in the execution trace",
> >>>>>>>>>>> but as an actual computation.
> >>>>>>>>>>>
> >>>>>>>>>>> I don;t think you know enough about how a program works to
> >>>>>>>>>>> get into a beginners programming course.
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>>>
> >>>>>>>>>> The actual behavior of the actual input is defined as the
> >>>>>>>>>> behavior of the correct and complete simulation of this
> >>>>>>>>>> input.
> >>>>>>>>>
> >>>>>>>>> Right, BUT, P didn't ask for a correct and complete
> >>>>>>>>> simulation of the input to H, it wanted a halting decision
> >>>>>>>>> that corresponded to that behavior, and it whated that in
> >>>>>>>>> finite time.
> >>>>>>>>>
> >>>>>>>>> Thus, replacing the call to H with a simulation of the input
> >>>>>>>>> to H is not a correct substitution.
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> It is the job of H to correctly predict what the behavior
> >>>>>>>>>> of its input would be if H performed a correct and complete
> >>>>>>>>>> simulation of this input:
> >>>>>>>>>
> >>>>>>>>> Nope, it is to correct predict what the behavior of its
> >>>>>>>>> input would be if given to a correct and complete
> >>>>>>>>> simulation of this input.
> >>>>>>>>>
> >>>>>>>>> SInce H DOESN'T DO a correct and complete simulation of its
> >>>>>>>>> input, you statement is nonsence.
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> // Never reaches the final state of Infinite_Loop
> >>>>>>>>>> (a) H0(Infinite_Loop)
> >>>>>>>>>>
> >>>>>>>>>> // Never reaches the final state of Infinite_Recursion
> >>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
> >>>>>>>>>>
> >>>>>>>>>> // Never reaches the final state of P
> >>>>>>>>>> (c) H(P,P)
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> But doesn't do a correct and complete simulation of its
> >>>>>>>>> input, so it didn't establish the needed criteria.
> >>>>>>>>>
> >>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN
> >>>>>>>> REPEATED MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT
> >>>>>>>> HAVE ACTUAL BRAIN DAMAGE.
> >>>>>>>>
> >>>>>>>> It is the job of H to correctly:
> >>>>>>>>
> >>>>>>>> PREDICT
> >>>>>>>> PREDICT
> >>>>>>>> PREDICT
> >>>>>>>> PREDICT
> >>>>>>>> PREDICT
> >>>>>>>> PREDICT
> >>>>>>>> PREDICT
> >>>>>>>> PREDICT
> >>>>>>>> what the behavior of its input would be if H performed a
> >>>>>>>> correct and complete simulation of this input:
> >>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
> >>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
> >>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
> >>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)... (on
> >>>>>>>> and on)
> >>>>>>>
> >>>>>>> You've told us numerous times that H does not do this - you
> >>>>>>> have even explained why it does not do this. So H is not
> >>>>>>> simulating itself correctly.
> >>>>>>
> >>>>>> I could have equally been told many times that cats are a kind
> >>>>>> of dog, that does not make it true.
> >>>>>>
> >>>>>> A simulating halt decider always predicts what the behavior of
> >>>>>> its input would be if a correct and complete simulation of this
> >>>>>> input was performed at the exact same place in the execution
> >>>>>> trace where H is invoked.
> >>>>>>
> >>>>>> void P(ptr x)
> >>>>>> {
> >>>>>> int Halt_Status = Simulate(x, x);
> >>>>>> if (Halt_Status)
> >>>>>> HERE: goto HERE;
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
> >>>>>> (b) that simulates P(P) that calls Simulate(P,P)
> >>>>>> (c) that simulates P(P) that calls Simulate(P,P)
> >>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and
> >>>>>> on)
> >>>>>
> >>>>> But the fact your H is recursive in nature PREVENTS it from
> >>>>> performing a "correct and complete simulation of this input". H
> >>>>> deciding the following is non-halting is an ERROR:
> >>>>>
> >>>>> void Px(ptr x)
> >>>>> {
> >>>>> (void)H(x, x);
> >>>>> return;
> >>>>> }
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Flibble does not even know enough to know that when H(Px,Px)
> >>>> correctly simulates its input that the "return" instruction is
> >>>> unreachable code by this simulated input.
> >>>
> >>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
> >>> that as a halt decider is supposed to return a decision to its
> >>> caller (Px in this case).
> >>>
> >>> /Flibble
> >>>
> >>
> >> In none of these cases will the simulated P(P) ever reach its own
> >> final state:
> >>
> >> void Px(u32 x)
> >> {
> >> H(x, x);
> >> return;
> >> }
> >>
> >> void Py(u32 x)
> >> {
> >> Simulate(x, x);
> >> return;
> >> }
> >>
> >> void Pz(u32 x)
> >> {
> >> UTM(x, x);
> >> return;
> >> }
> >
> > Error by non-equivalence: a halt decider (i.e. H) is supposed to
> > return a result to its caller in finite time.
> >
> > /Flibble
> >
>
> The outermost H returns to its caller, the first inner H is aborted
> before it is even invoked.

On 8/27/2022 9:54 AM, Richard Damon wrote:
> On 8/27/22 10:45 AM, olcott wrote:
>> On 8/27/2022 5:48 AM, Richard Damon wrote:
>>> On 8/26/22 11:29 PM, olcott wrote:
>>>> On 8/26/2022 9:46 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/26/22 10:36 PM, olcott wrote:
>>>>>> On 8/26/2022 8:59 PM, Richard Damon wrote:
>>>>>>> On 8/26/22 9:44 PM, olcott wrote:
>>>>>>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>>>>>>> On 8/26/22 8:13 PM, olcott wrote:
>>>>>
>>>>>>>>>> In none of these cases will the simulated P(P) ever reach its
>>>>>>>>>> own final state:
>>>>>>>>>>
>>>>>>>>>> void Px(u32 x)
>>>>>>>>>> {
>>>>>>>>>>     H(x, x);
>>>>>>>>>>     return;
>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> ^ This will when it is CORRECTLY and COMPLETELY Simulated,
>>>>>>>>> since H(Px,Px) has been shown to return 0 in finite time.
>>>>>>>>
>>>>>>>> So maybe you are as clueless as Flibble.
>>>>>>>>
>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>
>>>>>>>> Whether H simulates its input once or allows the recursive
>>>>>>>> simulations to continue forever there is never a case where
>>>>>>>> simulated Px ever reaches its final state.
>>>>>>>>
>>>>>>>> When H aborts its simulated input it never again simulates a
>>>>>>>> single instruction of its input thus all recursive emulations
>>>>>>>> are immediately dead in the water and cannot return to their
>>>>>>>> caller.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> No, it doesn't. May be you don't know your own code, or you are
>>>>>>> just a LIAR.
>>>>>>>
>>>>>>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at which
>>>>>>> point the original H(P,P) aborts its simulation and returns 0.
>>>>>>>
>>>>>>> THAT is what you code does.
>>>>>>>
>>>>>>> That means that a CORRECT and *COMPLETE* simulation of the input
>>>>>>> to H(P,P) is:
>>>>>>>
>>>>>>> Simulator simulated P(P) calling H(P,P).
>>>>>>> That H(P,P) is simulated to simulate a copy of P(P), and will
>>>>>>> simulate to it calling H(P,P).
>>>>>>> That simulated H(P,P) then aborts its simulation and is simulated
>>>>>>> to return to the P(P) that the outer simulation is simulating.
>>>>>>>
>>>>>>> THat simulated P(P) will reach its final state and return.
>>>>>>>
>>>>>>> Please point out the error in that description.
>>>>>>
>>>>>> The executed H(P,P) simulates P(P) that calls the simulated H(P,P)
>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>> until the executed H(P,P) aborts the whole chain causing
>>>>>> everything else to immediately stop.
>>>>>>
>>>>>>
>>>>>
>>>>> So, I said that, and the correct and complete simulation of the
>>>>> input sees that in the simulate call to H(P,P) and then sees the
>>>>> simulate P(P) reaching its final state.
>>>>>
>>>>
>>>> *You just don't seem to know enough about software engineering*
>>>> When the outermost executed H(P,P) aborts the simulation of its
>>>> input all of the simulations immediately stop because it was only
>>>> the outermost H that was driving them.
>>>>
>>>>  From the simulated P's point of view it is just like it hit an
>>>> abnormal termination core dump divide by zero error. No more steps
>>>> are simulated.
>>>>
>>>
>>> No, you have your details wrong, at least if you intend to be working
>>> on the Halting Problem. When H stops its simulation, the SIMULATION
>>> stops, but the behavior of the simulated P doesn't "stop", it just
>>> becomes unknown.
>>
>> You are totally incompetent about this.
>>
>>
>
> Then you can point out an actual error, or are YOU the incompetent one?
When a simulator quits simulating the simulated becomes static data and
stops running.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 8/27/2022 9:56 AM, Richard Damon wrote:
> On 8/27/22 10:48 AM, olcott wrote:
>> On 8/27/2022 6:08 AM, Mr Flibble wrote:
>>> On Fri, 26 Aug 2022 19:13:09 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott wrote:
>>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 3:50:37 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the input by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches line-by-line the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running: (a) H(P,P) simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P) (d) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your actual H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The behaviour of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) is that it terminates, or so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
>>>>>>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a complete
>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>> correctly performs a
>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the behavior
>>>>>>>>>>>>>>>>>>>>>>>> of this partial
>>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
>>>>>>>>>>>>>>>>>>>>>>> that it doesn't.
>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has entirely
>>>>>>>>>>>>>>>>>>>>>> different behavior
>>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its actual
>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is P
>>>>>>>>>>>>>>>>>>>>> and so H must report on what P does. The second
>>>>>>>>>>>>>>>>>>>>> argument is also P and so specifically H must
>>>>>>>>>>>>>>>>>>>>> report on what P(P) does. The idea that H(P, P) has
>>>>>>>>>>>>>>>>>>>>> some sort of "input" which is not P is nonsense.
>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
>>>>>>>>>>>>>>>>>>>>>> description always
>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>> H(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that calls
>>>>>>>>>>>>>>>>>>>>>> a simulated H(P,P) (d) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it into
>>>>>>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you twice
>>>>>>>>>>>>>>>>>>>>> in the quotes above alone.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE simulation of
>>>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and complete
>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is shown by
>>>>>>>>>>>>>>>>>>>> replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>        Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will do simply
>>>>>>>>>>>>>>>>>>>>> by working out what a non-aborting H would do and
>>>>>>>>>>>>>>>>>>>>> pretending a different H will do the same thing.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT WHAT A
>>>>>>>>>>>>>>>>>>>> NON-ABORTING SHD WOULD DO. That is what they are
>>>>>>>>>>>>>>>>>>>> supposed to do and that is how they work.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would do, AS
>>>>>>>>>>>>>>>>>>> IS.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs aren't
>>>>>>>>>>>>>>>>>>> actually Halt Deciders.
>>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>      > On Monday, July 25, 2022 at 12:10:34 AM UTC+1,
>>>>>>>>>>>>>>>>>>>>      > olcott wrote:
>>>>>>>>>>>>>>>>>>>>      >> If a simulating halt decider continues to
>>>>>>>>>>>>>>>>>>>>      >> correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>>      >> correctly matches a non-halting behavior
>>>>>>>>>>>>>>>>>>>>      >> pattern then this SHD is necessarily correct
>>>>>>>>>>>>>>>>>>>>      >> when it aborts its simulation and reports
>>>>>>>>>>>>>>>>>>>>      >> non-halting.
>>>>>>>>>>>>>>>>>>>>      >
>>>>>>>>>>>>>>>>>>>>      > Yes, *If* a simulating halt decider continues
>>>>>>>>>>>>>>>>>>>>      > to correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>>      > *correctly* matches a non- halting behaviour
>>>>>>>>>>>>>>>>>>>>      > pattern then this SHD is correct when it
>>>>>>>>>>>>>>>>>>>>      > aborts its simulation and reports non-halting.
>>>>>>>>>>>>>>>>>>>>      > [*some content snipped to stay focused on this
>>>>>>>>>>>>>>>>>>>>      > point*]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
>>>>>>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>> behavior of H0 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the behavior
>>>>>>>>>>>>>>>>>>>> of its input if H never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>> behavior of H1 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>        Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
>>>>>>>>>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No! The question isn't what its input would do it H
>>>>>>>>>>>>>>>>>>> never aborted it, since H does abort it, so you are
>>>>>>>>>>>>>>>>>>> asking a question that is a fantasy.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state of
>>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
>>>>>>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and stops,
>>>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
>>>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence ploughs
>>>>>>>>>>>>>>>>>>>>>>> on regardless.
>>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the correct
>>>>>>>>>>>>>>>>>>>>>> and complete simulation
>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final state of
>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many times you
>>>>>>>>>>>>>>>>>>>>> must realise you're pulling a fast one here. You
>>>>>>>>>>>>>>>>>>>>> claim that P(P) halts. However, you are trying to
>>>>>>>>>>>>>>>>>>>>> run an argument along the following lines:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return 1, but
>>>>>>>>>>>>>>>>>>> it incorrectly returns 0.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x); // H is
>>>>>>>>>>>>>>>>>>>> replaced with Simulate
>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the correct answers.
>>>>>>>>>>>>>>>>>>>>> My simulation is correct. My simulation says P(P)
>>>>>>>>>>>>>>>>>>>>> does not halt. Therefore it is acceptable to say
>>>>>>>>>>>>>>>>>>>>> that P(P) does not halt, and that H(P, P) = 0 is an
>>>>>>>>>>>>>>>>>>>>> acceptable answer."
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
>>>>>>>>>>>>>>>>>>> correct answer, or a correct simulation followed by
>>>>>>>>>>>>>>>>>>> sound and valid logic will give the corret answer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the simulation
>>>>>>>>>>>>>>>>>>>>> gives different results from the directly executed
>>>>>>>>>>>>>>>>>>>>> function, but instead of recognising that this
>>>>>>>>>>>>>>>>>>>>> proves your simulator is incorrect, you feel
>>>>>>>>>>>>>>>>>>>>> justified in rejecting the actual results actually
>>>>>>>>>>>>>>>>>>>>> produced by the function in favour of your "correct
>>>>>>>>>>>>>>>>>>>>> simulation".
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so H(P,P)
>>>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it any more
>>>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is set
>>>>>>>>>>>>>>>>>> up because it is easier to defeat than an opponent's
>>>>>>>>>>>>>>>>>> real argument.
>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so adept at
>>>>>>>>>>>>>>>>>> using the strawman deception that gullible fools accept
>>>>>>>>>>>>>>>>>> your deceitful attempts at rebuttal as correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
>>>>>>>>>>>>>>>>> doesn't do.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD) correctly
>>>>>>>>>>>>>>>>>> performs a partial simulation of its input and the
>>>>>>>>>>>>>>>>>> behavior of this partial simulation correctly matches a
>>>>>>>>>>>>>>>>>> correct non-halting behavior pattern then the SHD halt
>>>>>>>>>>>>>>>>>> decider can correctly report non-halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't provided one
>>>>>>>>>>>>>>>>> that you have actually proved is correct for this case.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct when-so-ever
>>>>>>>>>>>>>>>>>> matching this behavior pattern proves that the correct
>>>>>>>>>>>>>>>>>> and complete simulation of the input by SHD would never
>>>>>>>>>>>>>>>>>> reach the final state of this simulated input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and correct
>>>>>>>>>>>>>>>>> simulation of thd input, that is an INVALID definition.
>>>>>>>>>>>>>>>>> Note, you can't change the SHD to be a different machine
>>>>>>>>>>>>>>>>> if doing so changes the code at the input, which
>>>>>>>>>>>>>>>>> includes ALL the code that P calls, not just the code
>>>>>>>>>>>>>>>>> inside the "C function" of P.
>>>>>>>>>>>>>>>>>> H always reports on what the behavior of its input
>>>>>>>>>>>>>>>>>> would be if H was only a simulator and not a
>>>>>>>>>>>>>>>>>> simulating halt decider. All simulating halt deciders
>>>>>>>>>>>>>>>>>> must abort the simulation of inputs that would never
>>>>>>>>>>>>>>>>>> otherwise halt. Here are three examples of that:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual behavior
>>>>>>>>>>>>>>>>> of its input, but only the behavior of some other input
>>>>>>>>>>>>>>>>> built on a different H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
>>>>>>>>>>>>>>>> behavior of its input would be if the SHD performed a
>>>>>>>>>>>>>>>> correct and complete simulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any supporting
>>>>>>>>>>>>>> reasoning.
>>>>>>>>>>>>>
>>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't understand
>>>>>>>>>>>>> because you are too stupid.
>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU have quoted the soure of this before, but apparently
>>>>>>>>>>>>> your mind can't actually reason or remember.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>>>> A halt decider must always derive its halt status decision
>>>>>>>>>>>>>> on the basis of the actual behavior of the actual input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior" of the
>>>>>>>>>>>>> "actual input" for an x86 decider is what happens when you
>>>>>>>>>>>>> run that actual input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
>>>>>>>>>>>>> actual behavor of running P(P)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This means that the actual behavior of the actual input
>>>>>>>>>>>>>> would be the correct and complete simulation of the input
>>>>>>>>>>>>>> to H(P,P) at the exact same point in the execution trace
>>>>>>>>>>>>>> where H is invoked:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
>>>>>>>>>>>>> point is actually a call to H, and is looking for the
>>>>>>>>>>>>> Behavior or H which is supposed to be asking about the
>>>>>>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
>>>>>>>>>>>>> not as executed "At that point in the execution trace", but
>>>>>>>>>>>>> as an actual computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I don;t think you know enough about how a program works to
>>>>>>>>>>>>> get into a beginners programming course.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>> The actual behavior of the actual input is defined as the
>>>>>>>>>>>> behavior of the correct and complete simulation of this
>>>>>>>>>>>> input.
>>>>>>>>>>>
>>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete simulation
>>>>>>>>>>> of the input to H, it wanted a halting decision that
>>>>>>>>>>> corresponded to that behavior, and it whated that in finite
>>>>>>>>>>> time.
>>>>>>>>>>>
>>>>>>>>>>> Thus, replacing the call to H with a simulation of the input
>>>>>>>>>>> to H is not a correct substitution.
>>>>>>>>>>>>
>>>>>>>>>>>> It is the job of H to correctly predict what the behavior of
>>>>>>>>>>>> its input would be if H performed a correct and complete
>>>>>>>>>>>> simulation of this input:
>>>>>>>>>>>
>>>>>>>>>>> Nope, it is to correct predict what the behavior of its input
>>>>>>>>>>> would be if given to a correct and complete simulation of this
>>>>>>>>>>> input.
>>>>>>>>>>>
>>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation of its
>>>>>>>>>>> input, you statement is nonsence.
>>>>>>>>>>>>
>>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>
>>>>>>>>>>>> // Never reaches the final state of Infinite_Recursion
>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>
>>>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>
>>>>>>>>>>> But doesn't do a correct and complete simulation of its input,
>>>>>>>>>>> so it didn't establish the needed criteria.
>>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN REPEATED
>>>>>>>>>> MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT HAVE ACTUAL
>>>>>>>>>> BRAIN DAMAGE.
>>>>>>>>>>
>>>>>>>>>> It is the job of H to correctly:
>>>>>>>>>>
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> what the behavior of its input would be if H performed a
>>>>>>>>>> correct and complete simulation of this input:
>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)... (on
>>>>>>>>>> and on)
>>>>>>>>>
>>>>>>>>> You've told us numerous times that H does not do this - you have
>>>>>>>>> even explained why it does not do this. So H is not simulating
>>>>>>>>> itself correctly.
>>>>>>>>
>>>>>>>> I could have equally been told many times that cats are a kind of
>>>>>>>> dog, that does not make it true.
>>>>>>>>
>>>>>>>> A simulating halt decider always predicts what the behavior of
>>>>>>>> its input would be if a correct and complete simulation of this
>>>>>>>> input was performed at the exact same place in the execution
>>>>>>>> trace where H is invoked.
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>>       int Halt_Status = Simulate(x, x);
>>>>>>>>       if (Halt_Status)
>>>>>>>>         HERE: goto HERE;
>>>>>>>>       return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and on)
>>>>>>>
>>>>>>> But the fact your H is recursive in nature PREVENTS it from
>>>>>>> performing a "correct and complete simulation of this input".  H
>>>>>>> deciding the following is non-halting is an ERROR:
>>>>>>>
>>>>>>> void Px(ptr x)
>>>>>>> {
>>>>>>>      (void)H(x, x);
>>>>>>>      return;
>>>>>>> }
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> Flibble does not even know enough to know that when H(Px,Px)
>>>>>> correctly simulates its input that the "return" instruction is
>>>>>> unreachable code by this simulated input.
>>>>>
>>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
>>>>> that as a halt decider is supposed to return a decision to its
>>>>> caller (Px in this case).
>>>>>
>>>>> /Flibble
>>>>
>>>> In none of these cases will the simulated P(P) ever reach its own
>>>> final state:
>>>>
>>>> void Px(u32 x)
>>>> {
>>>>      H(x, x);
>>>>      return;
>>>> }
>>>>
>>>> void Py(u32 x)
>>>> {
>>>>      Simulate(x, x);
>>>>      return;
>>>> }
>>>>
>>>> void Pz(u32 x)
>>>> {
>>>>      UTM(x, x);
>>>>      return;
>>>> }
>>>
>>> Error by non-equivalence: a halt decider (i.e. H) is supposed to return
>>> a result to its caller in finite time.
>>>
>>> /Flibble
>>>
>>
>> The outermost H returns to its caller, the first inner H is aborted
>> before it is even invoked.
>>
>
> Which mean that an ACTUAL SIMULATION of the  actual input to H(Px,Px),
> which would be shown by Simulate(Px,Px) or UTM(Px, Px) would Halt, and
> thus H is incorrect.
>

On 8/27/22 11:01 AM, olcott wrote:
> On 8/27/2022 9:54 AM, Richard Damon wrote:
>> On 8/27/22 10:45 AM, olcott wrote:
>>> On 8/27/2022 5:48 AM, Richard Damon wrote:
>>>> On 8/26/22 11:29 PM, olcott wrote:
>>>>> On 8/26/2022 9:46 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 8/26/22 10:36 PM, olcott wrote:
>>>>>>> On 8/26/2022 8:59 PM, Richard Damon wrote:
>>>>>>>> On 8/26/22 9:44 PM, olcott wrote:
>>>>>>>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>>>>>>>> On 8/26/22 8:13 PM, olcott wrote:
>>>>>>
>>>>>>>>>>> In none of these cases will the simulated P(P) ever reach its
>>>>>>>>>>> own final state:
>>>>>>>>>>>
>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>> {
>>>>>>>>>>>     H(x, x);
>>>>>>>>>>>     return;
>>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> ^ This will when it is CORRECTLY and COMPLETELY Simulated,
>>>>>>>>>> since H(Px,Px) has been shown to return 0 in finite time.
>>>>>>>>>
>>>>>>>>> So maybe you are as clueless as Flibble.
>>>>>>>>>
>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>
>>>>>>>>> Whether H simulates its input once or allows the recursive
>>>>>>>>> simulations to continue forever there is never a case where
>>>>>>>>> simulated Px ever reaches its final state.
>>>>>>>>>
>>>>>>>>> When H aborts its simulated input it never again simulates a
>>>>>>>>> single instruction of its input thus all recursive emulations
>>>>>>>>> are immediately dead in the water and cannot return to their
>>>>>>>>> caller.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> No, it doesn't. May be you don't know your own code, or you are
>>>>>>>> just a LIAR.
>>>>>>>>
>>>>>>>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at which
>>>>>>>> point the original H(P,P) aborts its simulation and returns 0.
>>>>>>>>
>>>>>>>> THAT is what you code does.
>>>>>>>>
>>>>>>>> That means that a CORRECT and *COMPLETE* simulation of the input
>>>>>>>> to H(P,P) is:
>>>>>>>>
>>>>>>>> Simulator simulated P(P) calling H(P,P).
>>>>>>>> That H(P,P) is simulated to simulate a copy of P(P), and will
>>>>>>>> simulate to it calling H(P,P).
>>>>>>>> That simulated H(P,P) then aborts its simulation and is
>>>>>>>> simulated to return to the P(P) that the outer simulation is
>>>>>>>> simulating.
>>>>>>>>
>>>>>>>> THat simulated P(P) will reach its final state and return.
>>>>>>>>
>>>>>>>> Please point out the error in that description.
>>>>>>>
>>>>>>> The executed H(P,P) simulates P(P) that calls the simulated H(P,P)
>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>> until the executed H(P,P) aborts the whole chain causing
>>>>>>> everything else to immediately stop.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> So, I said that, and the correct and complete simulation of the
>>>>>> input sees that in the simulate call to H(P,P) and then sees the
>>>>>> simulate P(P) reaching its final state.
>>>>>>
>>>>>
>>>>> *You just don't seem to know enough about software engineering*
>>>>> When the outermost executed H(P,P) aborts the simulation of its
>>>>> input all of the simulations immediately stop because it was only
>>>>> the outermost H that was driving them.
>>>>>
>>>>>  From the simulated P's point of view it is just like it hit an
>>>>> abnormal termination core dump divide by zero error. No more steps
>>>>> are simulated.
>>>>>
>>>>
>>>> No, you have your details wrong, at least if you intend to be
>>>> working on the Halting Problem. When H stops its simulation, the
>>>> SIMULATION stops, but the behavior of the simulated P doesn't
>>>> "stop", it just becomes unknown.
>>>
>>> You are totally incompetent about this.
>>>
>>>
>>
>> Then you can point out an actual error, or are YOU the incompetent one?
> When a simulator quits simulating the simulated becomes static data and
> stops running.
>

Shows you don't understand simulation,

Yes, the Simulation ends, but the behavior of the simulated machine
continues, just THIS simulation can no longer show what happens.

You have your cause and effect backwards.

Remember, the decider isn't supposed to be answering about what its
particular simulation does, as that can vary, but what the actual
behavior of tme machine given as an input would be, or what the CORRECT
AND COMPLETE simulation of that input would do, even if this simulator
doesn't do that.

You are just to stupid to understand how something like a computer
works, likely because they are smarter than you.

On 8/27/2022 9:57 AM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 09:48:21 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 6:08 AM, Mr Flibble wrote:
>>> On Fri, 26 Aug 2022 19:13:09 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott wrote:
>>>>>>>>>
>>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM
>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 3:50:37
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution trace
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the simulation of the input by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches line-by-line the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running: (a) H(P,P) simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P) (d)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The behaviour
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P(P) is that it terminates, or so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
>>>>>>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by
>>>>>>>>>>>>>>>>>>>>>>>>>> this machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a
>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation.
>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>> correctly performs a
>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of this partial
>>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
>>>>>>>>>>>>>>>>>>>>>>> that it doesn't.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has
>>>>>>>>>>>>>>>>>>>>>> entirely different behavior
>>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its actual
>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is P
>>>>>>>>>>>>>>>>>>>>> and so H must report on what P does. The second
>>>>>>>>>>>>>>>>>>>>> argument is also P and so specifically H must
>>>>>>>>>>>>>>>>>>>>> report on what P(P) does. The idea that H(P, P)
>>>>>>>>>>>>>>>>>>>>> has some sort of "input" which is not P is
>>>>>>>>>>>>>>>>>>>>> nonsense.
>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
>>>>>>>>>>>>>>>>>>>>>> description always
>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>> H(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P) (d) that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it into
>>>>>>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you
>>>>>>>>>>>>>>>>>>>>> twice in the quotes above alone.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE simulation of
>>>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and
>>>>>>>>>>>>>>>>>>>> complete simulation of the input to H(P,P) is
>>>>>>>>>>>>>>>>>>>> shown by replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will do
>>>>>>>>>>>>>>>>>>>>> simply by working out what a non-aborting H would
>>>>>>>>>>>>>>>>>>>>> do and pretending a different H will do the same
>>>>>>>>>>>>>>>>>>>>> thing.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT
>>>>>>>>>>>>>>>>>>>> WHAT A NON-ABORTING SHD WOULD DO. That is what
>>>>>>>>>>>>>>>>>>>> they are supposed to do and that is how they work.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would do,
>>>>>>>>>>>>>>>>>>> AS IS.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs
>>>>>>>>>>>>>>>>>>> aren't actually Halt Deciders.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM
>>>>>>>>>>>>>>>>>>>> > UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>> >> If a simulating halt decider continues to
>>>>>>>>>>>>>>>>>>>> >> correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>> >> correctly matches a non-halting behavior
>>>>>>>>>>>>>>>>>>>> >> pattern then this SHD is necessarily
>>>>>>>>>>>>>>>>>>>> >> correct when it aborts its simulation and
>>>>>>>>>>>>>>>>>>>> >> reports non-halting.
>>>>>>>>>>>>>>>>>>>> >
>>>>>>>>>>>>>>>>>>>> > Yes, *If* a simulating halt decider
>>>>>>>>>>>>>>>>>>>> > continues to correctly simulate its input
>>>>>>>>>>>>>>>>>>>> > until it *correctly* matches a non- halting
>>>>>>>>>>>>>>>>>>>> > behaviour pattern then this SHD is correct
>>>>>>>>>>>>>>>>>>>> > when it aborts its simulation and reports
>>>>>>>>>>>>>>>>>>>> > non-halting. [*some content snipped to stay
>>>>>>>>>>>>>>>>>>>> > focused on this point*]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
>>>>>>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>> behavior of H0 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the
>>>>>>>>>>>>>>>>>>>> behavior of its input if H never aborted the
>>>>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>> behavior of H1 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
>>>>>>>>>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No! The question isn't what its input would do it H
>>>>>>>>>>>>>>>>>>> never aborted it, since H does abort it, so you are
>>>>>>>>>>>>>>>>>>> asking a question that is a fantasy.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state
>>>>>>>>>>>>>>>>>>>>>>>> of this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
>>>>>>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and stops,
>>>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
>>>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence ploughs
>>>>>>>>>>>>>>>>>>>>>>> on regardless.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the correct
>>>>>>>>>>>>>>>>>>>>>> and complete simulation
>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final state of
>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many times you
>>>>>>>>>>>>>>>>>>>>> must realise you're pulling a fast one here. You
>>>>>>>>>>>>>>>>>>>>> claim that P(P) halts. However, you are trying to
>>>>>>>>>>>>>>>>>>>>> run an argument along the following lines:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return 1,
>>>>>>>>>>>>>>>>>>> but it incorrectly returns 0.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x); // H is
>>>>>>>>>>>>>>>>>>>> replaced with Simulate
>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the correct
>>>>>>>>>>>>>>>>>>>>> answers. My simulation is correct. My simulation
>>>>>>>>>>>>>>>>>>>>> says P(P) does not halt. Therefore it is
>>>>>>>>>>>>>>>>>>>>> acceptable to say that P(P) does not halt, and
>>>>>>>>>>>>>>>>>>>>> that H(P, P) = 0 is an acceptable answer."
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
>>>>>>>>>>>>>>>>>>> correct answer, or a correct simulation followed by
>>>>>>>>>>>>>>>>>>> sound and valid logic will give the corret answer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the
>>>>>>>>>>>>>>>>>>>>> simulation gives different results from the
>>>>>>>>>>>>>>>>>>>>> directly executed function, but instead of
>>>>>>>>>>>>>>>>>>>>> recognising that this proves your simulator is
>>>>>>>>>>>>>>>>>>>>> incorrect, you feel justified in rejecting the
>>>>>>>>>>>>>>>>>>>>> actual results actually produced by the function
>>>>>>>>>>>>>>>>>>>>> in favour of your "correct simulation".
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so H(P,P)
>>>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it any
>>>>>>>>>>>>>>>>>>> more right.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is
>>>>>>>>>>>>>>>>>> set up because it is easier to defeat than an
>>>>>>>>>>>>>>>>>> opponent's real argument.
>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so adept
>>>>>>>>>>>>>>>>>> at using the strawman deception that gullible fools
>>>>>>>>>>>>>>>>>> accept your deceitful attempts at rebuttal as
>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>>>> simulation of a machine description always provides
>>>>>>>>>>>>>>>>>> the actual behavior specified by this machine
>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
>>>>>>>>>>>>>>>>> doesn't do.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>> correctly performs a partial simulation of its input
>>>>>>>>>>>>>>>>>> and the behavior of this partial simulation
>>>>>>>>>>>>>>>>>> correctly matches a correct non-halting behavior
>>>>>>>>>>>>>>>>>> pattern then the SHD halt decider can correctly
>>>>>>>>>>>>>>>>>> report non-halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't provided
>>>>>>>>>>>>>>>>> one that you have actually proved is correct for this
>>>>>>>>>>>>>>>>> case.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>> when-so-ever matching this behavior pattern proves
>>>>>>>>>>>>>>>>>> that the correct and complete simulation of the
>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state of
>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and correct
>>>>>>>>>>>>>>>>> simulation of thd input, that is an INVALID
>>>>>>>>>>>>>>>>> definition. Note, you can't change the SHD to be a
>>>>>>>>>>>>>>>>> different machine if doing so changes the code at the
>>>>>>>>>>>>>>>>> input, which includes ALL the code that P calls, not
>>>>>>>>>>>>>>>>> just the code inside the "C function" of P.
>>>>>>>>>>>>>>>>>> H always reports on what the behavior of its input
>>>>>>>>>>>>>>>>>> would be if H was only a simulator and not a
>>>>>>>>>>>>>>>>>> simulating halt decider. All simulating halt deciders
>>>>>>>>>>>>>>>>>> must abort the simulation of inputs that would never
>>>>>>>>>>>>>>>>>> otherwise halt. Here are three examples of that:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual
>>>>>>>>>>>>>>>>> behavior of its input, but only the behavior of some
>>>>>>>>>>>>>>>>> other input built on a different H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
>>>>>>>>>>>>>>>> behavior of its input would be if the SHD performed a
>>>>>>>>>>>>>>>> correct and complete simulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any
>>>>>>>>>>>>>> supporting reasoning.
>>>>>>>>>>>>>
>>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't
>>>>>>>>>>>>> understand because you are too stupid.
>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU have quoted the soure of this before, but apparently
>>>>>>>>>>>>> your mind can't actually reason or remember.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>>>> A halt decider must always derive its halt status
>>>>>>>>>>>>>> decision on the basis of the actual behavior of the
>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior" of the
>>>>>>>>>>>>> "actual input" for an x86 decider is what happens when you
>>>>>>>>>>>>> run that actual input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
>>>>>>>>>>>>> actual behavor of running P(P)
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This means that the actual behavior of the actual input
>>>>>>>>>>>>>> would be the correct and complete simulation of the input
>>>>>>>>>>>>>> to H(P,P) at the exact same point in the execution trace
>>>>>>>>>>>>>> where H is invoked:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
>>>>>>>>>>>>> point is actually a call to H, and is looking for the
>>>>>>>>>>>>> Behavior or H which is supposed to be asking about the
>>>>>>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
>>>>>>>>>>>>> not as executed "At that point in the execution trace",
>>>>>>>>>>>>> but as an actual computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I don;t think you know enough about how a program works to
>>>>>>>>>>>>> get into a beginners programming course.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>
>>>>>>>>>>>> The actual behavior of the actual input is defined as the
>>>>>>>>>>>> behavior of the correct and complete simulation of this
>>>>>>>>>>>> input.
>>>>>>>>>>>
>>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete
>>>>>>>>>>> simulation of the input to H, it wanted a halting decision
>>>>>>>>>>> that corresponded to that behavior, and it whated that in
>>>>>>>>>>> finite time.
>>>>>>>>>>>
>>>>>>>>>>> Thus, replacing the call to H with a simulation of the input
>>>>>>>>>>> to H is not a correct substitution.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It is the job of H to correctly predict what the behavior
>>>>>>>>>>>> of its input would be if H performed a correct and complete
>>>>>>>>>>>> simulation of this input:
>>>>>>>>>>>
>>>>>>>>>>> Nope, it is to correct predict what the behavior of its
>>>>>>>>>>> input would be if given to a correct and complete
>>>>>>>>>>> simulation of this input.
>>>>>>>>>>>
>>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation of its
>>>>>>>>>>> input, you statement is nonsence.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>
>>>>>>>>>>>> // Never reaches the final state of Infinite_Recursion
>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>
>>>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But doesn't do a correct and complete simulation of its
>>>>>>>>>>> input, so it didn't establish the needed criteria.
>>>>>>>>>>>
>>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN
>>>>>>>>>> REPEATED MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT
>>>>>>>>>> HAVE ACTUAL BRAIN DAMAGE.
>>>>>>>>>>
>>>>>>>>>> It is the job of H to correctly:
>>>>>>>>>>
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> PREDICT
>>>>>>>>>> what the behavior of its input would be if H performed a
>>>>>>>>>> correct and complete simulation of this input:
>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)... (on
>>>>>>>>>> and on)
>>>>>>>>>
>>>>>>>>> You've told us numerous times that H does not do this - you
>>>>>>>>> have even explained why it does not do this. So H is not
>>>>>>>>> simulating itself correctly.
>>>>>>>>
>>>>>>>> I could have equally been told many times that cats are a kind
>>>>>>>> of dog, that does not make it true.
>>>>>>>>
>>>>>>>> A simulating halt decider always predicts what the behavior of
>>>>>>>> its input would be if a correct and complete simulation of this
>>>>>>>> input was performed at the exact same place in the execution
>>>>>>>> trace where H is invoked.
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>> if (Halt_Status)
>>>>>>>> HERE: goto HERE;
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and
>>>>>>>> on)
>>>>>>>
>>>>>>> But the fact your H is recursive in nature PREVENTS it from
>>>>>>> performing a "correct and complete simulation of this input". H
>>>>>>> deciding the following is non-halting is an ERROR:
>>>>>>>
>>>>>>> void Px(ptr x)
>>>>>>> {
>>>>>>> (void)H(x, x);
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Flibble does not even know enough to know that when H(Px,Px)
>>>>>> correctly simulates its input that the "return" instruction is
>>>>>> unreachable code by this simulated input.
>>>>>
>>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
>>>>> that as a halt decider is supposed to return a decision to its
>>>>> caller (Px in this case).
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> In none of these cases will the simulated P(P) ever reach its own
>>>> final state:
>>>>
>>>> void Px(u32 x)
>>>> {
>>>> H(x, x);
>>>> return;
>>>> }
>>>>
>>>> void Py(u32 x)
>>>> {
>>>> Simulate(x, x);
>>>> return;
>>>> }
>>>>
>>>> void Pz(u32 x)
>>>> {
>>>> UTM(x, x);
>>>> return;
>>>> }
>>>
>>> Error by non-equivalence: a halt decider (i.e. H) is supposed to
>>> return a result to its caller in finite time.
>>>
>>> /Flibble
>>>
>>
>> The outermost H returns to its caller, the first inner H is aborted
>> before it is even invoked.
>
> Which means the input is not completely, correctly simulated contrary
> to what you keep claiming.
>
> /Flibble
>

On 8/27/2022 10:07 AM, Richard Damon wrote:
> On 8/27/22 11:01 AM, olcott wrote:
>> On 8/27/2022 9:54 AM, Richard Damon wrote:
>>> On 8/27/22 10:45 AM, olcott wrote:
>>>> On 8/27/2022 5:48 AM, Richard Damon wrote:
>>>>> On 8/26/22 11:29 PM, olcott wrote:
>>>>>> On 8/26/2022 9:46 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 8/26/22 10:36 PM, olcott wrote:
>>>>>>>> On 8/26/2022 8:59 PM, Richard Damon wrote:
>>>>>>>>> On 8/26/22 9:44 PM, olcott wrote:
>>>>>>>>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/26/22 8:13 PM, olcott wrote:
>>>>>>>
>>>>>>>>>>>> In none of these cases will the simulated P(P) ever reach
>>>>>>>>>>>> its own final state:
>>>>>>>>>>>>
>>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>>> {
>>>>>>>>>>>>     H(x, x);
>>>>>>>>>>>>     return;
>>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> ^ This will when it is CORRECTLY and COMPLETELY Simulated,
>>>>>>>>>>> since H(Px,Px) has been shown to return 0 in finite time.
>>>>>>>>>>
>>>>>>>>>> So maybe you are as clueless as Flibble.
>>>>>>>>>>
>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>>
>>>>>>>>>> Whether H simulates its input once or allows the recursive
>>>>>>>>>> simulations to continue forever there is never a case where
>>>>>>>>>> simulated Px ever reaches its final state.
>>>>>>>>>>
>>>>>>>>>> When H aborts its simulated input it never again simulates a
>>>>>>>>>> single instruction of its input thus all recursive emulations
>>>>>>>>>> are immediately dead in the water and cannot return to their
>>>>>>>>>> caller.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, it doesn't. May be you don't know your own code, or you are
>>>>>>>>> just a LIAR.
>>>>>>>>>
>>>>>>>>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at
>>>>>>>>> which point the original H(P,P) aborts its simulation and
>>>>>>>>> returns 0.
>>>>>>>>>
>>>>>>>>> THAT is what you code does.
>>>>>>>>>
>>>>>>>>> That means that a CORRECT and *COMPLETE* simulation of the
>>>>>>>>> input to H(P,P) is:
>>>>>>>>>
>>>>>>>>> Simulator simulated P(P) calling H(P,P).
>>>>>>>>> That H(P,P) is simulated to simulate a copy of P(P), and will
>>>>>>>>> simulate to it calling H(P,P).
>>>>>>>>> That simulated H(P,P) then aborts its simulation and is
>>>>>>>>> simulated to return to the P(P) that the outer simulation is
>>>>>>>>> simulating.
>>>>>>>>>
>>>>>>>>> THat simulated P(P) will reach its final state and return.
>>>>>>>>>
>>>>>>>>> Please point out the error in that description.
>>>>>>>>
>>>>>>>> The executed H(P,P) simulates P(P) that calls the simulated H(P,P)
>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>> until the executed H(P,P) aborts the whole chain causing
>>>>>>>> everything else to immediately stop.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So, I said that, and the correct and complete simulation of the
>>>>>>> input sees that in the simulate call to H(P,P) and then sees the
>>>>>>> simulate P(P) reaching its final state.
>>>>>>>
>>>>>>
>>>>>> *You just don't seem to know enough about software engineering*
>>>>>> When the outermost executed H(P,P) aborts the simulation of its
>>>>>> input all of the simulations immediately stop because it was only
>>>>>> the outermost H that was driving them.
>>>>>>
>>>>>>  From the simulated P's point of view it is just like it hit an
>>>>>> abnormal termination core dump divide by zero error. No more steps
>>>>>> are simulated.
>>>>>>
>>>>>
>>>>> No, you have your details wrong, at least if you intend to be
>>>>> working on the Halting Problem. When H stops its simulation, the
>>>>> SIMULATION stops, but the behavior of the simulated P doesn't
>>>>> "stop", it just becomes unknown.
>>>>
>>>> You are totally incompetent about this.
>>>>
>>>>
>>>
>>> Then you can point out an actual error, or are YOU the incompetent one?
>> When a simulator quits simulating the simulated becomes static data
>> and stops running.
>>
>
> Shows you don't understand simulation,

Shows that you and Flibble should be put back on blocked.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 8/27/22 11:03 AM, olcott wrote:
> On 8/27/2022 9:56 AM, Richard Damon wrote:
>> On 8/27/22 10:48 AM, olcott wrote:
>>> On 8/27/2022 6:08 AM, Mr Flibble wrote:
>>>> On Fri, 26 Aug 2022 19:13:09 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>>>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott wrote:
>>>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 3:50:37 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the input by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches line-by-line the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running: (a) H(P,P) simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P) (d) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your actual H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The behaviour of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) is that it terminates, or so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a complete
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>> correctly performs a
>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the behavior
>>>>>>>>>>>>>>>>>>>>>>>>> of this partial
>>>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
>>>>>>>>>>>>>>>>>>>>>>>> that it doesn't.
>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has entirely
>>>>>>>>>>>>>>>>>>>>>>> different behavior
>>>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its actual
>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is P
>>>>>>>>>>>>>>>>>>>>>> and so H must report on what P does. The second
>>>>>>>>>>>>>>>>>>>>>> argument is also P and so specifically H must
>>>>>>>>>>>>>>>>>>>>>> report on what P(P) does. The idea that H(P, P) has
>>>>>>>>>>>>>>>>>>>>>> some sort of "input" which is not P is nonsense.
>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>> description always
>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>> H(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that calls
>>>>>>>>>>>>>>>>>>>>>>> a simulated H(P,P) (d) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it into
>>>>>>>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you twice
>>>>>>>>>>>>>>>>>>>>>> in the quotes above alone.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE simulation of
>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and complete
>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is shown by
>>>>>>>>>>>>>>>>>>>>> replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>        Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will do simply
>>>>>>>>>>>>>>>>>>>>>> by working out what a non-aborting H would do and
>>>>>>>>>>>>>>>>>>>>>> pretending a different H will do the same thing.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT WHAT A
>>>>>>>>>>>>>>>>>>>>> NON-ABORTING SHD WOULD DO. That is what they are
>>>>>>>>>>>>>>>>>>>>> supposed to do and that is how they work.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would do, AS
>>>>>>>>>>>>>>>>>>>> IS.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs aren't
>>>>>>>>>>>>>>>>>>>> actually Halt Deciders.
>>>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>      > On Monday, July 25, 2022 at 12:10:34 AM UTC+1,
>>>>>>>>>>>>>>>>>>>>>      > olcott wrote:
>>>>>>>>>>>>>>>>>>>>>      >> If a simulating halt decider continues to
>>>>>>>>>>>>>>>>>>>>>      >> correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>>>      >> correctly matches a non-halting behavior
>>>>>>>>>>>>>>>>>>>>>      >> pattern then this SHD is necessarily correct
>>>>>>>>>>>>>>>>>>>>>      >> when it aborts its simulation and reports
>>>>>>>>>>>>>>>>>>>>>      >> non-halting.
>>>>>>>>>>>>>>>>>>>>>      >
>>>>>>>>>>>>>>>>>>>>>      > Yes, *If* a simulating halt decider continues
>>>>>>>>>>>>>>>>>>>>>      > to correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>>>      > *correctly* matches a non- halting behaviour
>>>>>>>>>>>>>>>>>>>>>      > pattern then this SHD is correct when it
>>>>>>>>>>>>>>>>>>>>>      > aborts its simulation and reports non-halting.
>>>>>>>>>>>>>>>>>>>>>      > [*some content snipped to stay focused on this
>>>>>>>>>>>>>>>>>>>>>      > point*]
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
>>>>>>>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>>> behavior of H0 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the behavior
>>>>>>>>>>>>>>>>>>>>> of its input if H never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>>> behavior of H1 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>        Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
>>>>>>>>>>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No! The question isn't what its input would do it H
>>>>>>>>>>>>>>>>>>>> never aborted it, since H does abort it, so you are
>>>>>>>>>>>>>>>>>>>> asking a question that is a fantasy.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state of
>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
>>>>>>>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and stops,
>>>>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
>>>>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence ploughs
>>>>>>>>>>>>>>>>>>>>>>>> on regardless.
>>>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the correct
>>>>>>>>>>>>>>>>>>>>>>> and complete simulation
>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final state of
>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many times you
>>>>>>>>>>>>>>>>>>>>>> must realise you're pulling a fast one here. You
>>>>>>>>>>>>>>>>>>>>>> claim that P(P) halts. However, you are trying to
>>>>>>>>>>>>>>>>>>>>>> run an argument along the following lines:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return 1, but
>>>>>>>>>>>>>>>>>>>> it incorrectly returns 0.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x); // H is
>>>>>>>>>>>>>>>>>>>>> replaced with Simulate
>>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the correct answers.
>>>>>>>>>>>>>>>>>>>>>> My simulation is correct. My simulation says P(P)
>>>>>>>>>>>>>>>>>>>>>> does not halt. Therefore it is acceptable to say
>>>>>>>>>>>>>>>>>>>>>> that P(P) does not halt, and that H(P, P) = 0 is an
>>>>>>>>>>>>>>>>>>>>>> acceptable answer."
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
>>>>>>>>>>>>>>>>>>>> correct answer, or a correct simulation followed by
>>>>>>>>>>>>>>>>>>>> sound and valid logic will give the corret answer.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the simulation
>>>>>>>>>>>>>>>>>>>>>> gives different results from the directly executed
>>>>>>>>>>>>>>>>>>>>>> function, but instead of recognising that this
>>>>>>>>>>>>>>>>>>>>>> proves your simulator is incorrect, you feel
>>>>>>>>>>>>>>>>>>>>>> justified in rejecting the actual results actually
>>>>>>>>>>>>>>>>>>>>>> produced by the function in favour of your "correct
>>>>>>>>>>>>>>>>>>>>>> simulation".
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so H(P,P)
>>>>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it any more
>>>>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is set
>>>>>>>>>>>>>>>>>>> up because it is easier to defeat than an opponent's
>>>>>>>>>>>>>>>>>>> real argument.
>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so adept at
>>>>>>>>>>>>>>>>>>> using the strawman deception that gullible fools accept
>>>>>>>>>>>>>>>>>>> your deceitful attempts at rebuttal as correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
>>>>>>>>>>>>>>>>>> doesn't do.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD) correctly
>>>>>>>>>>>>>>>>>>> performs a partial simulation of its input and the
>>>>>>>>>>>>>>>>>>> behavior of this partial simulation correctly matches a
>>>>>>>>>>>>>>>>>>> correct non-halting behavior pattern then the SHD halt
>>>>>>>>>>>>>>>>>>> decider can correctly report non-halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't provided one
>>>>>>>>>>>>>>>>>> that you have actually proved is correct for this case.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct when-so-ever
>>>>>>>>>>>>>>>>>>> matching this behavior pattern proves that the correct
>>>>>>>>>>>>>>>>>>> and complete simulation of the input by SHD would never
>>>>>>>>>>>>>>>>>>> reach the final state of this simulated input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and correct
>>>>>>>>>>>>>>>>>> simulation of thd input, that is an INVALID definition.
>>>>>>>>>>>>>>>>>> Note, you can't change the SHD to be a different machine
>>>>>>>>>>>>>>>>>> if doing so changes the code at the input, which
>>>>>>>>>>>>>>>>>> includes ALL the code that P calls, not just the code
>>>>>>>>>>>>>>>>>> inside the "C function" of P.
>>>>>>>>>>>>>>>>>>> H always reports on what the behavior of its input
>>>>>>>>>>>>>>>>>>> would be if H was only a simulator and not a
>>>>>>>>>>>>>>>>>>> simulating halt decider. All simulating halt deciders
>>>>>>>>>>>>>>>>>>> must abort the simulation of inputs that would never
>>>>>>>>>>>>>>>>>>> otherwise halt. Here are three examples of that:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual behavior
>>>>>>>>>>>>>>>>>> of its input, but only the behavior of some other input
>>>>>>>>>>>>>>>>>> built on a different H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
>>>>>>>>>>>>>>>>> behavior of its input would be if the SHD performed a
>>>>>>>>>>>>>>>>> correct and complete simulation of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any supporting
>>>>>>>>>>>>>>> reasoning.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't understand
>>>>>>>>>>>>>> because you are too stupid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> YOU have quoted the soure of this before, but apparently
>>>>>>>>>>>>>> your mind can't actually reason or remember.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>>>>> A halt decider must always derive its halt status decision
>>>>>>>>>>>>>>> on the basis of the actual behavior of the actual input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior" of the
>>>>>>>>>>>>>> "actual input" for an x86 decider is what happens when you
>>>>>>>>>>>>>> run that actual input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
>>>>>>>>>>>>>> actual behavor of running P(P)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This means that the actual behavior of the actual input
>>>>>>>>>>>>>>> would be the correct and complete simulation of the input
>>>>>>>>>>>>>>> to H(P,P) at the exact same point in the execution trace
>>>>>>>>>>>>>>> where H is invoked:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
>>>>>>>>>>>>>> point is actually a call to H, and is looking for the
>>>>>>>>>>>>>> Behavior or H which is supposed to be asking about the
>>>>>>>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
>>>>>>>>>>>>>> not as executed "At that point in the execution trace", but
>>>>>>>>>>>>>> as an actual computation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I don;t think you know enough about how a program works to
>>>>>>>>>>>>>> get into a beginners programming course.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>> The actual behavior of the actual input is defined as the
>>>>>>>>>>>>> behavior of the correct and complete simulation of this
>>>>>>>>>>>>> input.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete simulation
>>>>>>>>>>>> of the input to H, it wanted a halting decision that
>>>>>>>>>>>> corresponded to that behavior, and it whated that in finite
>>>>>>>>>>>> time.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus, replacing the call to H with a simulation of the input
>>>>>>>>>>>> to H is not a correct substitution.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is the job of H to correctly predict what the behavior of
>>>>>>>>>>>>> its input would be if H performed a correct and complete
>>>>>>>>>>>>> simulation of this input:
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, it is to correct predict what the behavior of its input
>>>>>>>>>>>> would be if given to a correct and complete simulation of this
>>>>>>>>>>>> input.
>>>>>>>>>>>>
>>>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation of its
>>>>>>>>>>>> input, you statement is nonsence.
>>>>>>>>>>>>>
>>>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>
>>>>>>>>>>>>> // Never reaches the final state of Infinite_Recursion
>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>
>>>>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>
>>>>>>>>>>>> But doesn't do a correct and complete simulation of its input,
>>>>>>>>>>>> so it didn't establish the needed criteria.
>>>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN REPEATED
>>>>>>>>>>> MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT HAVE ACTUAL
>>>>>>>>>>> BRAIN DAMAGE.
>>>>>>>>>>>
>>>>>>>>>>> It is the job of H to correctly:
>>>>>>>>>>>
>>>>>>>>>>> PREDICT
>>>>>>>>>>> PREDICT
>>>>>>>>>>> PREDICT
>>>>>>>>>>> PREDICT
>>>>>>>>>>> PREDICT
>>>>>>>>>>> PREDICT
>>>>>>>>>>> PREDICT
>>>>>>>>>>> PREDICT
>>>>>>>>>>> what the behavior of its input would be if H performed a
>>>>>>>>>>> correct and complete simulation of this input:
>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)... (on
>>>>>>>>>>> and on)
>>>>>>>>>>
>>>>>>>>>> You've told us numerous times that H does not do this - you have
>>>>>>>>>> even explained why it does not do this. So H is not simulating
>>>>>>>>>> itself correctly.
>>>>>>>>>
>>>>>>>>> I could have equally been told many times that cats are a kind of
>>>>>>>>> dog, that does not make it true.
>>>>>>>>>
>>>>>>>>> A simulating halt decider always predicts what the behavior of
>>>>>>>>> its input would be if a correct and complete simulation of this
>>>>>>>>> input was performed at the exact same place in the execution
>>>>>>>>> trace where H is invoked.
>>>>>>>>>
>>>>>>>>> void P(ptr x)
>>>>>>>>> {
>>>>>>>>>       int Halt_Status = Simulate(x, x);
>>>>>>>>>       if (Halt_Status)
>>>>>>>>>         HERE: goto HERE;
>>>>>>>>>       return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and on)
>>>>>>>>
>>>>>>>> But the fact your H is recursive in nature PREVENTS it from
>>>>>>>> performing a "correct and complete simulation of this input".  H
>>>>>>>> deciding the following is non-halting is an ERROR:
>>>>>>>>
>>>>>>>> void Px(ptr x)
>>>>>>>> {
>>>>>>>>      (void)H(x, x);
>>>>>>>>      return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> Flibble does not even know enough to know that when H(Px,Px)
>>>>>>> correctly simulates its input that the "return" instruction is
>>>>>>> unreachable code by this simulated input.
>>>>>>
>>>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
>>>>>> that as a halt decider is supposed to return a decision to its
>>>>>> caller (Px in this case).
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> In none of these cases will the simulated P(P) ever reach its own
>>>>> final state:
>>>>>
>>>>> void Px(u32 x)
>>>>> {
>>>>>      H(x, x);
>>>>>      return;
>>>>> }
>>>>>
>>>>> void Py(u32 x)
>>>>> {
>>>>>      Simulate(x, x);
>>>>>      return;
>>>>> }
>>>>>
>>>>> void Pz(u32 x)
>>>>> {
>>>>>      UTM(x, x);
>>>>>      return;
>>>>> }
>>>>
>>>> Error by non-equivalence: a halt decider (i.e. H) is supposed to return
>>>> a result to its caller in finite time.
>>>>
>>>> /Flibble
>>>>
>>>
>>> The outermost H returns to its caller, the first inner H is aborted
>>> before it is even invoked.
>>>
>>
>> Which mean that an ACTUAL SIMULATION of the  actual input to H(Px,Px),
>> which would be shown by Simulate(Px,Px) or UTM(Px, Px) would Halt, and
>> thus H is incorrect.
>>
>
> No you brain dead moron and aborted process is not a process that halts.
> No simulated Px ever reaches its own "return" instruction.