Re: DDD correctly emulated by H0

On 6/22/24 8:01 PM, olcott wrote:

On 6/22/2024 3:10 PM, Richard Damon wrote:

On 6/22/24 3:45 PM, olcott wrote:

On 6/22/2024 2:22 PM, Richard Damon wrote:

On 6/22/24 2:53 PM, olcott wrote:

On 6/22/2024 1:50 PM, Fred. Zwarts wrote:

Op 22.jun.2024 om 15:11 schreef olcott:

>
It is a verified fact that the behavior that finite string DDD presents
to HH0 is that when DDD correctly simulated by HH0 calls HH0(DDD) that
this call DOES NOT RETURN.
>
It is a verified fact that the behavior that finite string DDD presents
to HH1 is that when DDD correctly simulated by HH0 calls HH1(DDD) that
this call DOES RETURN.
>
I don't get why people here insist on lying about verified facts.
>

>
We know that 'verified fact' for you means 'my wish'.

>
Ignoramus?
>
When we stipulate that the only measure of a correct emulation is the semantics of the x86 programming language then we see that when DDD is correctly emulated by H0 that its call to H0(DDD) cannot possibly return.
>
_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
>
When we define H1 as identical to H0 except that DDD does not call H1 then we see that when DDD is correctly emulated by H1 that its call to H0(DDD) does return. This is the same behavior as the directly executed DDD().
>

>
By a strict interpreation of your measure, this input has UNDEFIINED BEHAVIOR, so it is improper to ask about it.
>

>
That is a stupid thing to say. The behavior of THE INPUT
is specified by the semantics of the x86 programming language.
>

>
Right, so what does a call to a location of memory that doesn't exist do?

 Liar

How is a QUESTION a LIE?
I guess you feel it must be because I put you on the spot about your deciet in your framing of the problem.

 When we stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language then we see
that when DDD is correctly emulated by H0 that its call to
H0(DDD) cannot possibly return.

Right, so what do you do when you run out of instructions to simulate?
Your logic just BLOWS UP.

 _DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
 

This exposes the LIE of your system. YOu CAN'T correctly x86 emulate a partial program, becuase it isn't prpgram with behavior to emulate.
PERIOD.
That means, the call to H0(DDD), to have any actual meaning, must incluede *ALL* the instrutions in memory that are going to be used as part of the input, and thus, DDD is TIED to the H0 that we started with, so your "trick" of changing it is shows to just be a LIE.
You just don't understand that behavior is determined of an SPECIFIC program, a specific instance of the template AFTER pairing it with the decider it is to foil, and when you ask about other deciders looking at THIS input, the input can't change.
There goes your two decades down the drain.