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.