Re: Anyone that disagrees with this is not telling the truth --- V5

On 8/19/24 10:47 PM, olcott wrote:

*Everything that is not expressly stated below is*
*specified as unspecified*

Looks like you still have this same condition.
I thought you said you removed it.

 void DDD()
{
   HHH(DDD);
   return;
}
 _DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
 *It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)

But it can't emulate DDD correctly past 4 instructions, since the 5th instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention HHHn below, so that changes, but DDD, so the input doesn't and thus is CAN'T be part of the input.

 X = DDD emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
 The above claim boils down to this: (X ∧ Y) ↔ Z

And neither X or Y are possible.

 x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.

Which is irrelevent and a LIE as if HHHn is part of the input, that input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is available to HHHn when it emulates its input, that DDD must actually be DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Your problem is that for any other DDDn / HHHn, you don't have Y so you don't have Z.

 void EEE()
{
   HERE: goto HERE;
}
 HHHn correctly predicts the behavior of DDD the same
way that HHHn correctly predicts the behavior of EEE.
 

Nope, HHHn can form a valid inductive proof of the input.
It can't for DDDn, since when we move to HHHn+1 we no longer have DDDn but DDDn+1, which is a different input.
And in fact, if we give this DDDn that calls HHHn to an independent actual correct x86 emulator, then we see that DDDn calls HHHn which will simulate n steps of the DDDn it was given, then abort its emulation and return to the DDDn that called it which returns.
Thus, ALL DDDn, with a finite n are Halting, and only DDD∞ is non-halting.
You have been shown thins many times, and your inability to understand it just shows that you seem to have a funny-mental problem with your understanding of the basics of the things you are trying to talk about, and have shown yourself to be nothing but a stupid liar.