On Monday, June 27, 2022 at 5:50:39 PM UTC-4, olcott wrote:
> On 6/27/2022 4:16 PM, Dennis Bush wrote:
> > On Monday, June 27, 2022 at 5:14:03 PM UTC-4, olcott wrote:
> >> On 6/27/2022 4:04 PM, Dennis Bush wrote:
> >>> On Monday, June 27, 2022 at 5:00:41 PM UTC-4, olcott wrote:
> >>>> On 6/27/2022 3:07 PM, Dennis Bush wrote:
> >>>>> On Monday, June 27, 2022 at 4:03:53 PM UTC-4, olcott wrote:
> >>>>>> On 6/27/2022 2:39 PM, Dennis Bush wrote:
> >>>>>>> On Monday, June 27, 2022 at 3:35:53 PM UTC-4, olcott wrote:
> >>>>>>>> On 6/27/2022 2:13 PM, Dennis Bush wrote:
> >>>>>>>>> On Monday, June 27, 2022 at 3:02:47 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 6/27/2022 1:51 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Monday, June 27, 2022 at 2:41:50 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 6/27/2022 1:08 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Monday, June 27, 2022 at 1:59:58 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 6/27/2022 12:03 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Monday, June 27, 2022 at 9:28:22 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 6/27/2022 7:58 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Monday, June 27, 2022 at 8:50:05 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 6/27/2022 7:40 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Monday, June 27, 2022 at 8:34:22 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 6/27/2022 7:26 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Monday, June 27, 2022 at 8:14:31 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 6/27/2022 6:57 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Monday, June 27, 2022 at 7:11:21 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> *This is the outline of the complete refutation*
> >>>>>>>>>>>>>>>>>>>>>>>> *of the only rebuttal that anyone has left*
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>>>>>>>>>> never reaches the "ret" instruction of P.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> What *does* perform a complete and correct emulation of the input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> The above two are proven to be verified facts entirely on the basis of
> >>>>>>>>>>>>>>>>>>>>>>>> the semantics of the x86 language.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> A nonsense statement can't be a "fact", verified or otherwise.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
> >>>>>>>>>>>>>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
> >>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Which for H(P,P) is BY DEFINITION is the behavior of P(P). The halting problem says that H MUST implement the following mapping (i.e. the halting function):
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> H(x,y)==1 if and only if x(y) halts, and
> >>>>>>>>>>>>>>>>>>>>>>> H(x,y)==0 if and only if x(y) does not halt.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> H does not perform this mapping.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> P(P) is provably not the actual behavior of the actual input.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> It is BY DEFINITION. So if H comes up with something different that means it did something wrong, specifically it aborted a halting computation too soon.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> P(P);
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f0](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f1](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f3](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f6](01) 50 push eax
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f7](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>> [000011fa](01) 51 push ecx
> >>>>>>>>>>>>>>>>>>>>>>>> [000011fb](05) e820feffff call 00001020
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> [00001200](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>> [00001203](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>> [00001205](02) 7402 jz 00001209
> >>>>>>>>>>>>>>>>>>>>>>>> [00001207](02) ebfe jmp 00001207
> >>>>>>>>>>>>>>>>>>>>>>>> [00001209](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>> [0000120a](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000120a]
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>>>>>>>>>>>> [00001210](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>> [00001211](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>> [00001213](05) 68f0110000 push 000011f0
> >>>>>>>>>>>>>>>>>>>>>>>> [00001218](05) e8d3ffffff call 000011f0
> >>>>>>>>>>>>>>>>>>>>>>>> [0000121d](03) 83c404 add esp,+04
> >>>>>>>>>>>>>>>>>>>>>>>> [00001220](02) 33c0 xor eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>> [00001222](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>> [00001223](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [00001223]
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>>>>>>>>>>>>>>>> address address data code language
> >>>>>>>>>>>>>>>>>>>>>>>> ======== ======== ======== ========= =============
> >>>>>>>>>>>>>>>>>>>>>>>> [00001210][00101fba][00000000] 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>> [00001211][00101fba][00000000] 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>> [00001213][00101fb6][000011f0] 68f0110000 push 000011f0 // push P
> >>>>>>>>>>>>>>>>>>>>>>>> [00001218][00101fb2][0000121d] e8d3ffffff call 000011f0 // call P
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f0][00101fae][00101fba] 55 push ebp // enter executed P
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f1][00101fae][00101fba] 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f3][00101fae][00101fba] 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f6][00101faa][000011f0] 50 push eax // push P
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f7][00101faa][000011f0] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>> [000011fa][00101fa6][000011f0] 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>> [000011fb][00101fa2][00001200] e820feffff call 00001020 // call H
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Begin Simulation Execution Trace Stored at:21206e
> >>>>>>>>>>>>>>>>>>>>>>>> Address_of_H:1020
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f0][0021205a][0021205e] 55 push ebp // enter emulated P
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f1][0021205a][0021205e] 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f3][0021205a][0021205e] 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f6][00212056][000011f0] 50 push eax // push P
> >>>>>>>>>>>>>>>>>>>>>>>> [000011f7][00212056][000011f0] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>> [000011fa][00212052][000011f0] 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>> [000011fb][0021204e][00001200] e820feffff call 00001020 // call emulated H
> >>>>>>>>>>>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected Simulation Stopped
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> H knows its own machine address and on this basis it can easily
> >>>>>>>>>>>>>>>>>>>>>>>> examine its stored execution_trace of P (see above) to determine:
> >>>>>>>>>>>>>>>>>>>>>>>> (a) P is calling H with the same arguments that H was called with.
> >>>>>>>>>>>>>>>>>>>>>>>> (b) No instructions in P could possibly escape this otherwise infinitely
> >>>>>>>>>>>>>>>>>>>>>>>> recursive emulation.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> FALSE. P contains these instructions:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> if (Decide_Halting(&execution_trace, &decoded, code_end, &master_state,
> >>>>>>>>>>>>>>>>>>>>>>> &slave_state, &slave_stack, Address_of_H, P, I))
> >>>>>>>>>>>>>>>>>>>>>>> goto END_OF_CODE;
> >>>>>>>>>>>>>>>>>>>>>>> return 0; // Does not halt
> >>>>>>>>>>>>>>>>>>>>>>> END_OF_CODE:
> >>>>>>>>>>>>>>>>>>>>>>> return 1; // Input has normally terminated
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> That *can* and *do* prevent infinite recursive emulation in a *correct* and *complete* emulation
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> (c) H aborts its emulation of P before its call to H is emulated.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> And in doing so it fails to see that the call to H, since H is a computation, will aborts *its* simulation of P and return 0 to the outer P being emulated, which would cause it to halt, making H(P,P)==0 wrong.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> [00001200][00101fae][00101fba] 83c408 add esp,+08 // return to
> >>>>>>>>>>>>>>>>>>>>>>>> executed P
> >>>>>>>>>>>>>>>>>>>>>>>> [00001203][00101fae][00101fba] 85c0 test eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>> [00001205][00101fae][00101fba] 7402 jz 00001209
> >>>>>>>>>>>>>>>>>>>>>>>> [00001209][00101fb2][0000121d] 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>> [0000120a][00101fb6][000011f0] c3 ret // return from
> >>>>>>>>>>>>>>>>>>>>>>>> executed P
> >>>>>>>>>>>>>>>>>>>>>>>> [0000121d][00101fba][00000000] 83c404 add esp,+04
> >>>>>>>>>>>>>>>>>>>>>>>> [00001220][00101fba][00000000] 33c0 xor eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>> [00001222][00101fbe][00100000] 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>> [00001223][00101fc2][00000000] c3 ret // ret from main
> >>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(878) / 67 = 13 pages
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> I've stated in detail why you're wrong. Now you need to explain in detail why I'm wrong.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Failure to do so, which includes simply restating your original point, will be taken as admission that what I've stated is correct.
> >>>>>>>>>>>>>>>>>>>>>> H correctly predicts that its complete and correct x86 emulation of its
> >>>>>>>>>>>>>>>>>>>>>> input never reaches the the "ret" instruction of P..
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Repeating your original point.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> This is the actual behavior of the input to H(P,P)..
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> P(P) is not the actual behavior of the input to H(P,P).
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Again, repeating your original point.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Never reaching the "ret" instruction means that P does not halt.
> >>>>>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
> >>>>>>>>>>>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
> >>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>> Therefore H(P,P)==0 is correct.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> And again, repeating your original point.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> So no explanation as to why I'm wrong, just a repetition of your original points.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> That means you accept that what I've said is true, and that H(P,P)==0 is wrong.
> >>>>>>>>>>>>>>>>>>>> You rebuttal is based on rejecting the verified fact that a simulating
> >>>>>>>>>>>>>>>>>>>> halt decider correctly predicts that its correctly simulated input will
> >>>>>>>>>>>>>>>>>>>> never reach the final state "ret" instruction of this input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> FALSE. The correctly simulated input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
> >>>>>>>>>>>>>>>>>> First of all I am not talking about UTM's.
> >>>>>>>>>>>>>>>>>> I am talking about x86 emulation.
> >>>>>>>>>>>>>>>>>> Try to encode what you mean, here is my guess:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> void P(u32 x)
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> if (emulate_x86(x, x))
> >>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> P is a computation and therefore it can't be changed, nor can anything that it calls. I mean UTM(P,P). The simplest way to implement this is:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> void UTM(u32 x, u32 y)
> >>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>> x(y)
> >>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> H cannot by definition perform a correct and complete emulation if it aborts, so the input must be passed to something that does, i.e. a UTM, for the source of truth.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> A simulating halt decider correctly simulates its input until it
> >>>>>>>>>>>>>>>> correctly determines that this simulated input would never reach its
> >>>>>>>>>>>>>>>> final state.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> But H isn't such a decider, because the simulated input does reach a final state when correctly simulated, i.e. by UTM(P,P), therefore H(P,P)==0 is wrong.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The semantics of the x86 language conclusively proves that H(P,P)
> >>>>>>>>>>>>>> correctly determines/predicts that its complete and correct x86
> >>>>>>>>>>>>>> emulation of its input would never reach the "ret" instruction of P.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> As previously stated, this is nonsense. Failure to explain *in detail* why the below is wrong will be taken as an admission that it is correct.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
> >>>>>>>>>>>> I NEVER SAID that H does a complete and correct simulation of its input.
> >>>>>>>>>>>
> >>>>>>>>>>> Yes you did:
> >>>>>>>>>>>
> >>>>>>>>>>>> a) The complete and correct x86 emulation of the input to H(P,P) by H never reaches the "ret" instruction of P.
> >>>>>>>>>>>
> >>>>>>>>>> This does not say that H does a complete emulation.
> >>>>>>>>>> A simulating halt decider correctly simulates its input until it
> >>>>>>>>>> correctly determines that this simulated input would never reach its
> >>>>>>>>>> final state.
> >>>>>>>>>
> >>>>>>>>> Which in the case of H(P,P) it doesn't since the correctly simulated input i.e. UTM(P,P) halts. H gets the wrong answer because it aborts too soon.
> >>>>>>>>>
> >>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>> [000015b8](01) 55 push ebp
> >>>>>>>>>> [000015b9](02) 8bec mov ebp,esp
> >>>>>>>>>> [000015bb](02) ebfe jmp 000015bb
> >>>>>>>>>> [000015bd](01) 5d pop ebp
> >>>>>>>>>> [000015be](01) c3 ret
> >>>>>>>>>> Size in bytes:(0007) [000015be]
> >>>>>>>>>>
> >>>>>>>>>> The complete and correct x86 emulation of the input to H0(Infinite_Loop)
> >>>>>>>>>> by H0 never reaches the "ret" instruction of Infinite_Loop.
> >>>>>>>>>
> >>>>>>>>> If H0 *actually* does a complete and correct emulation, then yes.
> >>>>>>>> void Infinite_Loop()
> >>>>>>>> {
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> You are not bright enough to tell that an infinite loop doesn't stop
> >>>>>>>> running?
> >>>>>>>
> >>>>>>> My point was that if H0 does in fact do a correct and complete simulation then the behavior of H0(Infinite_Loop)
> >>>>>> You didn't notice that it is ridiculously stupid to think that an
> >>>>>> infinite loop can be completely simulated?
> >>>>>
> >>>>> It can, by a simulator that *never* aborts.
> >>>>>
> >>>>> If H0 does in fact do a correct and complete simulation by never aborting then the behavior of H0(Infinite_Loop) is a source of truth for H(Infinite_Loop). H(P,P) is not a source of truth for H(P,P) because H does not do a correct and complete simulation. UTM(P,P) does and it halts, so H(P,P)==0 is wrong
> >>>> When you say that *only* an actual correct and complete simulation of an
> >>>> input correctly predicts the behavior the complete and correct
> >>>> simulation of this input
> >>>
> >>> No, I'm saying that only the correct and complete simulation of an input defines what the correct answer is. UTM(Infinite_Loop) does not halt, so H(Infinite_Loop)==0 is correct. UTM(P,P) does halt, so H(P,P)==0 is wrong.
> >>>
> >> Simply ignoring the effect of pathological self-reference does not
> >> actually make it go away.
> >
> > The self reference is what makes H gives the wrong answer. All you did is explain how it got the wrong answer.
> You may continue to disagree with the semantics of the x86 language by
> yourself. You have sufficiently proven that you have no interest in an
> honest dialogue.

So no rebuttal. Which means you admit that the above is correct.

>
> tautology
> 1.2 Logic A statement that is true by necessity or by virtue of its
> logical form.
> https://www.lexico.com/definition/tautology
>
> THIS IS A TAUTOLOGY

And therefore is a non-statement

> THIS IS A TAUTOLOGY

And therefore is a non-statement