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

On 10/18/24 10:10 AM, olcott wrote:

On 10/18/2024 6:17 AM, Richard Damon wrote:

On 10/17/24 11:47 PM, olcott wrote:

On 10/17/2024 10:27 PM, Richard Damon wrote:

On 10/17/24 9:47 PM, olcott wrote:

On 10/17/2024 8:13 PM, Richard Damon wrote:

On 10/17/24 7:31 PM, olcott wrote:

_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]
>
When DDD is correctly emulated by HHH according
to the semantics of the x86 language DDD cannot
possibly reach its own machine address [00002183]
no matter what HHH does.
>
+-->[00002172]-->[00002173]-->[00002175]-->[0000217a]--+
+------------------------------------------------------+
>
That may not line up that same way when view
>
>
>
>
https://en.wikipedia.org/wiki/State_diagram
>

>
>
Except that 0000217a doesn't go to 00002172, but to 000015d2
>

>
IS THIS OVER YOUR HEAD?
What is the first machine address of DDD that HHH
emulating itself emulating DDD would reach?
>

>
Yes, HHH EMULATES the code at that address,

>
Which HHH emulates what code at which address?
>

>
Everyone, just once, which you should know, but ignore.
>
The Emulating HHH sees those addresses at its begining and then never again.
>
Then the HHH that it is emulating will see those addresses, but not the outer one that is doing that emulation of HHH.
>
Then the HHH that the second HHH is emulating will, but neither of the outer 2 HHH.
>
And so on.
>
Which HHH do you think EVER gets back to 00002172?
>
What instruction do you think that it emulates that would tell it to do so?
>
It isn't the call instruction at 0000217a, as that tells it to go into HHH.
>
At best the trace is:
>
00002172
00002173
00002175
0000217a
conditional emulation of 00002172
conditional emulation of 00002173
conditional emulation of 00002175
conditional emulation of 0000217a
CE of CE of 00002172
...
>

 OK great this is finally good progress.
 

The "state" never repeats, it is alway a new state,

 Every emulated DDD has an identical process state at every point
in its emulation trace when adjusting for different top of stack values.

Nope, remember, each of those levels are CONDITIONAL, and thus, if HHH is defined to abort its simulaiton, as it is, then none of the HHH's actually NEED To abort, as if they were changed (without changing their input, so it still calls the HHH that does abort, per the definition of the problem), then that emulation would go to the point where it sees the emulator it is emulating abort its emulation and return.
Your LIE is based on trying to change the input when you do this hypothetcal step, which you are not allowed to do, as then you are just showing you are LYING about talking about the behavior of the specifed behavior of DDD, which includes ALL of the code it uses, including that of HHH.

 

and if HHH decides to abort its emulation, it also should know that every level of condition emulation it say will also do the same thing,

 If I understand his words correctly Mike has already disagreed
with this. Let's see if you can understand my reasoning.
 

Big *IF*, I beleive he has pointed out that you don't understand his words correctly

Not exactly. Each HHH can only abort its emulation when its
abort criteria has been met. The outermost HHH can see one
more execution trace than the next inner one thus meets its
abort criteria first.

Sort of, Each HHH *WILL* abort its emulation when its abort criteria has been met, and the abortion of the emulation of that machine doesn't "stop" the behavior of that machine, only the behavior of the partial emulation, which isn't the same thing.

 Message-ID: <rLmcnQQ3-N_tvH_4nZ2dnZfqnPGdnZ2d@brightview.co.uk>
On 3/1/2024 12:41 PM, Mike Terry wrote:
 >
 > Obviously a simulator has access to the internal state
 > (tape contents etc.) of the simulated machine. No problem
 > there.
 

Yes, it could be posible for HHH to somehow figure out what HHH is doing and detetect that it has started another layer of emulation. The issue is that HHH needs to KNOW that it is emulating a copy of itself, which you only detect by using a non-turing complete system.

This seems to indicate that the Turing machine UTM version of
HHH can somehow see each of the state transitions of the DDD
resulting from emulating its own Turing machine description
emulating DDD.

The problem is detecting that it *IS* running a copy of itself. This is the problem I have been pointing out to youy for years.

 Even though this is a little different for Turing machines it
is equivalent in essence to HHH being able to see the steps of
the DDD resulting from HHH emulating itself emulating this DDD.

But you can only detect that your are emulating HHH because of your non-turing complete system.

 *Joes can't seem to understand this*
Only the outer-most HHH meets its abort criteria first, thus
unless it aborts as soon as it meets this criteria none of
them will ever abort.

No, it only meets its criteria first in its reference frame. The machine that it is emulating doesn't know (and its behavior doesn't care) that it is being emulated, and that just continues till it get to the same point.
You just don't seem to understand that "behavior" doesn't require the actual performance of it, but is a mathematical concept that comes into existance the moment the program is created. We just don't KNOW what that behavior is until we something to find out about it.

 

and thus the call HHH at 0000217a will be returned from, > and HHH has no idea what will happen after that, so it KNOWS it is ignorant of the answer.
>

 That you don't quite yet understand the preceding points
will make it impossible for you to understand any reply
to the above point.
 

No, YOU are just showing you don't understand the difference between the TRUTH of the behavior, which was established when the program was created, and the KNOWLEDGE of that behavior, that HHH never actually gets, because it stops too soon.
But then, that has been one of your problems for years, not understanding the difference between Truth and Knowledge.