Re: Every sufficiently competent C programmer knows --- Semantic Property of Finite String

On 3/14/2025 6:02 AM, joes wrote:

Am Thu, 13 Mar 2025 20:48:09 -0500 schrieb olcott:

On 3/13/2025 4:21 PM, Richard Heathfield wrote:

On 13/03/2025 20:48, dbush wrote:

On 3/13/2025 4:46 PM, olcott wrote:

On 3/13/2025 4:27 AM, joes wrote:

Am Wed, 12 Mar 2025 21:41:34 -0500 schrieb olcott:

On 3/12/2025 7:56 PM, dbush wrote:

On 3/12/2025 8:41 PM, olcott wrote:

>
NOT WHEN IT IS STIPULATED THAT THE BEHAVIOR BEING MEASURED IS

The direct execution of DDD

is proven to be different than the behavior of DDD emulated by HHH
according to the semantics of the x86 language.

Which is weird, considering that a simulator should produce the same
behaviour.

 Doesn't it?
 

DECIDERS ARE REQUIRED TO REPORT ON THE SEMANTIC OR SYNTACTIC
PROPERTY OF THEIR INPUT FINITE STRINGS.

And not if the input called a different simulator that didn't abort.
>

Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly reach its own final
state no matter what HHH does.
Replacing the code of HHH1 with an unconditional simulator and
subsequently running HHH1(DD) does reach its own final state.
If someone was not a liar they would say that these are different
computations.
>

Only because one changes the code that DD runs and one doesn't

>
It hardly matters. Either his emulation faithfully and correctly
establishes and reports (for EVERY program anyone cares to feed it) the
actual halting behaviour exhibited by the program it's emulating, or it
doesn't.
>

That everyone expects the behavior of the directly executed DDD to be
the same as DDD correctly emulated by HHH1 is verified as a factually
correct expectation.
That everyone expects the behavior of the directly executed DDD to be
the same as DDD correctly emulated by HHH is verified as a factually
incorrect expectation.

A simulation should not differ from the actual execution. Why should it?
 

If it doesn't, it doesn't, and it's a lot of fuss over nothing.
But if it /does/, then we're right back at Turing's proof, because a
working emulator is just another way of running the code, and is
therefore superfluous to requirements. It adds nothing to the debate,
because we can just run the code and get the same answer the emulator
would provide.
>

For the first time in the history of mankind it proves that a simulation
of a virtual machine according to the semantics of this machine language
DOES NOT ALWAYS HAVE THE SAME BEHAVIOR AS THE DIRECT EXECUTION OF THIS
SAME MACHINE

Bold claim. How does that make sense?
 

PATHOLOGICAL SELF REFERENCE DOES CHANGE SEMANTICS

As opposed to what? Of course a different program has different semantics.
 

This sentence is not true: "This sentence is not true"
The exact same word-for-word sentence IS TRUE IN THIS DIFFERING CONTEXT
THAT DOES NOT HAVE PSR.

It's a different sentence.
 

It is the same word-for-word sentence with
pathological self-reference removed.

In other words, the emulator is a canard, a distraction, a cul-de-sac,
and a complete waste of time. If it happens to work, great! Well done
that man. But it doesn't affect the HP logic one microscopically
minuscule millijot.

The emulator proves the actual behavior specified by the INPUT

No, the direct execution does.
 

We really cannot simply ignore the pathological self-reference
specified by DDD to HHH  and not specified by DDD to HHH1.

That people disagree with the semantics of the x86 language proves how
deeply indoctrinated they are.

With what semantics?

I will give it to you in C
void DDD()
{
   HHH(DDD);
   return;
}
The above code specifies that
DDD correctly simulated by HHH specifies that DDD will
continue to call HHH(DDD) in recursive simulation and
WILL NOT CALL HHH1(DDD) IN RECURSIVE SIMULATION.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer