Re: Verified facts regarding the software engineering of DDD, HHH, and HHH1 ---

On 10/26/24 10:17 AM, olcott wrote:

On 10/26/2024 9:10 AM, joes wrote:

Am Sat, 26 Oct 2024 08:47:11 -0500 schrieb olcott:

On 10/25/2024 11:07 PM, Richard Damon wrote:

On 10/25/24 7:18 PM, olcott wrote:

On 10/25/2024 5:17 PM, Richard Damon wrote:

On 10/25/24 5:54 PM, olcott wrote:

On 10/25/2024 10:45 AM, Richard Damon wrote:

On 10/25/24 9:37 AM, olcott wrote:

On 10/25/2024 7:27 AM, Richard Damon wrote:

On 10/24/24 9:04 PM, olcott wrote:

On 10/24/2024 6:23 PM, Richard Damon wrote:

On 10/24/24 2:19 PM, olcott wrote:

On 10/23/2024 9:48 PM, Richard Damon wrote:

On 10/23/24 10:33 PM, olcott wrote:

On 10/23/2024 6:16 PM, Richard Damon wrote:

On 10/23/24 8:33 AM, olcott wrote:

On 10/23/2024 6:12 AM, Richard Damon wrote:

On 10/23/24 12:04 AM, olcott wrote:

On 10/22/2024 10:47 PM, Richard Damon wrote:

On 10/22/24 11:25 PM, olcott wrote:

>

When termination analyzers analyze C functions for
termination the measure of termination is reaching the
"return" statement.

Rigjt, when the BEHAIVIOR of the function is to do so, and
that behavior is DEFINED to be the results of direct
execution,

That is not DDD emulated by HHH according to the semantics
of the x86 language. That is DDD emulated by HHH1 according
to the semantics of the x86 language.

Depends on which of the equivocations you are meaning.
If we are talking about the behavior of the PROGRAM DDD.

In other words you are saying that DDD must be emulated by HHH
violating the semantics of the x86 language.

Where did I say that?

The directly executed DDD has the same behavior as DDD emulated
by HHH1 according to the semantics of the x86 language.
The only way for DDD emulated by HHH to have this same behavior
(that includes DDD calling itself) is to ignore the call to
itself.

Nope, as "according to the semantics of the x86 language" is an
OBJECTIVE standard, and thus the only meaning of behavior of "the
call itself" is to look at what the x86 processor does on that
call.

*That lame excuse tries to pretend that UTMs don't exist*

Nope. But UTMs will never abort their emulation of their input, or
they are not a UTM.

You claimed that emulation is an incorrect basis and I proved you
wrong.

No, I said a PARTIAL emulation is an incorrect basis.

*This does not say that*
On 10/25/2024 7:27 AM, Richard Damon wrote:
  > Nope, as "according to the semantics of the x86 language" is an
  > OBJECTIVE standard, and thus the only meaning of behavior of "the
  > call itself" is to look at what the x86 processor does on that
  > call.
This does reject emulation out-of-hand and forbids an x86 processor to
emulate itself recursively as is required to form the isomorphism to
the halting problem.

No. Emulation just needs to match the execution (duh).

Nope, the key is that *IF* you can show that the results of the
emulation will match the behavior of the actual machine,

Then you can show that the emulation by HHH disobeys the semantics of
the x86 language:

You could also show the actual behaviour disobeys them.

When DDD is emulated by HHH according to the semantics of the x86
language then HHH must emulate itself emulating DDD.

Just as in the direct execution.

When DDD is emulated by HHH1 according to the semantics of the x86
language then HHH1 does not emulate itself emulating DDD.
DDD emulated by HHH1 has the same behavior as when DDD is directly
executed.

Do you think that it is not directly executed according to x86 semantics?
>

 Maybe you get overloaded with too many points.
Here is the one key point:
 DDD emulated by HHH must emulate itself emulating DDD.
DDD emulated by HHH1 must NOT emulate itself emulating DDD.
DDD emulated by HHH1 has the same behavior as executed DDD.
 

And since HHH can not "correctly" (as in completely) emulate HHH (in a way that indicates its actual behavior), it can not be the basis of the right answer, so tring to define it as such is just an error.