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

Richard Heathfield <rjh@cpax.org.uk> writes:

On 14/03/2025 11:02, 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:

>
<snip>
>

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?

>
Why indeed? But of course it doesn't matter. If the simulation
correctly reports the outcome, it factors itself out of the equation
and Turing's logic stands. And if it doesn't, it gives broken results
that cannot be trusted to support a conclusion.
>

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?

>
Well, it doesn't, but you weren't expecting it to, were you?

No, it doesn't make sense, but I can imagine something similar to that
claim that might make sense if it were logically possible (which it
isn't).  And to be clear, I haven't read the full context.

A simulation that doesn't have the same behavior as the thing it's
simulating (which is what Olcott claims here) simply is not a
simulation, so his claim is self-contradictory.  But such a
not-quite-simulation might still be useful.

The Halting Problem is about taking an arbitrary program and input and
determining whether the program halts or not.  This is of course
trivially possible in many special cases:
    int main(void) { return 0; }  // halts
    int main(void) { while (1); } // does not halt
and difficult but possible in other cases, but impossible in general.

What Olcott *might* be claiming is that he can determine whether any
arbitrary program halts by "simulating" it in a way that isn't a true
simulation, but that tells us whether it halts or not.  So perhaps
while it's running the simulation, it's somehow able to detect and
report that the simulated program does or does not eventually halt.
(I haven't studied what he's written enough to have any idea how
it would do this, and I don't intend to.)

Which could all make sense if it were mathematically possible,
but of course it isn't.

Another point: Olcott seems to waver back and forth about just
what he's claiming.  Sometimes he claims to have solved the
Halting Problem, implying that he's able to determine whether any
given program halts or not.  (That would imply that he could solve
Goldbach's Conjecture, among other things, but I haven't seen him
do so.)  And sometimes he makes a lesser claim, that he has refuted
the proof (or all proofs) of the insolubility of the Halting Problem.
If true, that would be a big deal, but it wouldn't lead to any
concrete results.  It wouldn't even imply that the Halting Problem
can be solved, only that the proofs are invalid.

Note that I am *not* asking Olcott to explain just what he's
claiming.  He can do so if he likes, but I do not promise to read
it or respond to it.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */