Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES

On 6/19/2024 11:29 AM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 6/19/2024 10:39 AM, Fred. Zwarts wrote:

Op 19.jun.2024 om 16:55 schreef olcott:

On 6/19/2024 8:46 AM, Fred. Zwarts wrote:

 [ .... ]
 

It seems really to difficult for you. So, you prefer to forget or
ignore it.
The 'call' instruction at 000020aa is incorrectly simulated.

 

As a matter of fact it is not incorrectly simulated.
I am showing this with HH0 instead of H0 because
the trace provided by HH0 is easier to understand.

 So instead of why you think that instruction is correctly simulated, you
just spam the newsgroup with more barely penetrable machine code.
 

H0 is required to halt, i.e. to return, but your simulation does not
show the 'ret' instruction of H0.

 

Yes it does not show this yet HH0 does simulate itself simulating DDD.

 

If the eight lines of DDD correctly simulated by HH0 were mixed in
with the 150 pages of HH0 simulating itself it would be too difficult
to see the behavior of DDD. The reader would have to carefully search
for the machine addresses of DDD that only occur every 19 pages.

 Of course, you could always have found these places yourself and included
them in a post, thus making it plausible that these places actually
exist, and that you have done such an execution trace.
 

The best way to do this is to make a compiler flag that enables
both versions to be output. After more than three years not one
person could correctly understand the single page of x86 code
so I am sure that 150 more pages are not going to make this easier
for them.

I will adapt HH0 so that it does show HH0 simulating itself
simulating DDD.

 

It seems you are so confused that you do not understand it.
Therefore, you think it is a change of subject or gibberish. Showing
that it is over your head.
Instead of fixing the problem, you just repeat the claim without any
new argument.
The simulation fails, because it is aborted one cycle too soon,
before the simulated H0 would reach its 'ret' instruction. A correct
simulation would see this. Unfortunately, H0 is unable to correctly
simulate itself.

 

Because the executed HH0 always has at least one more execution trace
than any of its simulated instances unless it aborts the simulation
after a fixed number of repeating states, none of them do.

 

What is your problem:
1) You say: 'HH0 always has at least one more execution trace than any
of its simulated instances'. That is correct. That is true even if it
does abort. Is that over your head?
2) If it aborts, it misses the fact that the simulation of itself would
also abort one execution trace later. Is that over your head?
3) If it misses the fact that its simulation of itself would halt one
execution trace later, it is incorrect to report non-halting. Is that
over your head?

 

What is your problem: 1, 2, or 3.
If you do not even understand it, you better stop talking about it.

 

*THIS IS SIMPLY OVER YOUR HEAD*
*THIS IS SIMPLY OVER YOUR HEAD*
*THIS IS SIMPLY OVER YOUR HEAD*

 [ more spam deleted. ]
 

Every C programmer that knows what an x86 emulator is knows that when
H0 emulates the machine language of Infinite_Loop, Infinite_Recursion,
and DDD that it must abort these emulations so that itself can terminate
normally.

 

Every C programmer has agreed thus you simply don't know these things
well enough.

 

All of the C programmers that have stated an opinion (at least six)
have agreed with me.

That is another of your lies.  Every C programmer has NOT agreed this.
In particular, I haven't.
 

All of the C programmers on the C programming groups have
agreed with me.

Fred knows these things extremely well.  It is you that appears to have a
problem with them.
 

*If that was actually true then you would stop dodging this challenge*
It is dishonest for you to erase this challenge and call it spam:
void DDD()
{
   H0(DDD);
}
_DDD()
[000020a2] 55         push ebp      ; housekeeping
[000020a3] 8bec       mov ebp,esp   ; housekeeping
[000020a5] 68a2200000 push 000020a2 ; push DDD
[000020aa] e8f3f9ffff call 00001aa2 ; call H0
[000020af] 83c404     add esp,+04   ; housekeeping
[000020b2] 5d         pop ebp       ; housekeeping
[000020b3] c3         ret           ; never gets here
Size in bytes:(0018) [000020b3]
Exactly which step of DDD emulated by H0 was emulated
incorrectly such that this emulation would be complete?
AKA DDD emulated by H0 reaches machine address [000020b3]

-- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

 

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer