Re: Proof that DDD specifies non-halting behavior --- point by point

On 8/13/24 10:38 PM, olcott wrote:

On 8/13/2024 9:29 PM, Richard Damon wrote:

On 8/13/24 8:52 PM, olcott wrote:

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]
>
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
>

>
Nope, it is just the correct PARTIAL emulation of the first N instructions of DDD, and not of all of DDD,

 That is what I said dufuss.

Nope. You didn't. I added clairifying words, pointing out why you claim is incorrect.
For an emulation to be "correct" it must be complete, as partial emulations are only partially correct, so without the partial modifier, they are not correct.

 

>

A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.

>
Nope, if a HHH returns to its caller,

 *Try to show exactly how DDD emulated by HHH returns to its caller*
(the first one doesn't even have a caller)
Use the above machine language instructions to show this.
 

Remember how English works:
When you ask "How DDD emulated by HHH returns to its callers".
The SUBJECT of the sentence is "DDD", that is the name of a PROGRAM, and DDD includes all the code of HHH, If it doesn't we can't even correctly emulate DDD past the call instruction.
The VERB of the sentence is "Returns" that is the action of DDD that we are talking about.
The OBJECT of the sentence is "its callers" which indicates who we are asking if DDD returns to.
The phrase "emulated by HHH" is a modifier phrase attached to DDD to specify which of potential different DDDs we are talking about, and make it clear that we are talking about the DDD that calls the HHH that we are talking abut.
Thus, the behavior of that DDD, is to call HHH(DDD), at which point this subroutine HHH will emulate the code specified by its input to emulate N instructions, in that time it will not reach a final state, and so it will return the value 0 to its caller, which is DDD, and DDD will then return to its caller, showing how it does it.
The sentence you seem to want to talk about would be something more like:
The simulation of DDD by HHH will never return to its caller.
Here, the subject is the "simulation", of what: DDD, by whom: HHH.
Yes, that simulation will never reach a return of DDD, so that statement would be true.
The problem is that it makes it clear that if HHH aborts is simulation that is only partial that clearly doesn't mean that the full simulation of the input would be non-halting.
And that clarity is your problem, because it breaks your next step.
Your argument NEEDS there to be wiggle room to switch meaning, because it needs to generate the needed LIE by doing that.
Sorry, you are just proving that you just don't know what you are talking about, or that you are just pathetically a pathological liar that doesn't care how much you lie.