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

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.

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.

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

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

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

--
Alan Mackenzie (Nuremberg, Germany).