Re: A state transition diagram proves ... GOOD PROGRESS

On 10/19/24 6:53 AM, olcott wrote:

On 10/19/2024 2:22 AM, joes wrote:

Am Fri, 18 Oct 2024 16:46:03 -0500 schrieb olcott:

On 10/18/2024 4:24 PM, joes wrote:

Am Fri, 18 Oct 2024 15:18:46 -0500 schrieb olcott:

On 10/18/2024 2:51 PM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 10/18/2024 2:10 PM, joes wrote:

>

The existence of the check has an effect right from the start;
besides, it is true the first time it is executed.

So maybe you have ADD too. You can't seem to pay attention when
things are explained to you many different times several different
ways.

What you call "explaining" is in actual fact the assertion of
falsehoods.  This is usually called lying.
The variable Root does indeed affect your program.

*I never say that it didn't*

You said nothing at all. Productive communication would have included
an agreement and clarification.
>

The "root" variable has NO EFFECT WHAT-SO-EVER on the correctness or
completeness of HHH emulating itself emulating DDD until this DDD
calls HHH(DDD).

DDD does nothing else but call HHH, and Root is part of HHH, so is
simulated the first time around.

It is possible that I am not communicating this clearly enough
The root variable cannot possibly have have any effect what-so-ever on
the correctness of HHH emulating DDD or HHH emulating itself emulating
DDD until the root variable tests true.

 

It has the effect of not aborting the simulation.

 It has this effect only after every competent software
engineer can independently verify that it is correct:
 Emulating termination analyzer HHH emulates its input DDD
according to the semantics of the x86 language (including HHH
emulating itself emulating DDD) until HHH correctly determines
that its emulated DDD would never stop running unless aborted.

Except that the correct determination doesn't happen in the case that Root doesn't affect the behavior of the emulated DDD, so that impurity does have affect.
Remember, DDD as an input, even to the hypothocated HHH that has been modified to not abort at the point it does, MUST continue to call the HHH that DOES abort there, by the definition of a "program", (which includes the concept of a "function") as that definition requires said entity to contain *ALL* the code it uses, and thus all of HHH and anything it calls, which thus CAN'T be changed in the analysis.
Thus the Hypothetical HHH that has been changed needs to be put somewhere else in memory (or a separate memory space looking into this memory space), and thus not affect DDD.
Then, since it has been shown that this DDD calling the HHH that does abort, will reach the final return when fully executed or emulated, and thus the correct answer to the question about will it terminate is YES, it is terminating, and the NO answer is just wrong.

 

Apart from that, Root is true in the root invocation of HHH (duh).
>

 The other place that root is true has no effect on the correctness
of the x86 emulation. Do I have to tell you this 175 times before
you notice that I said it once?
 

Except that a partial x86 emulation (or a partial any type of emulation) doesn't show the final behavior of a program, and thus doesn't show that it will NEVER reach a point. The fact that without the affect of that variable there, a complete emulation of the code that is actually the program DDD (which includes that HHH *WIL* abort its emulation at the point it does) would reach the final return instruction.
All you have done is shown that you don't understand what you are talking about.