Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD)

On 5/9/2025 4:48 AM, joes wrote:

Am Thu, 08 May 2025 22:34:35 -0500 schrieb olcott:

On 5/8/2025 10:14 PM, Mike Terry wrote:

On 09/05/2025 03:13, olcott wrote:

On 5/8/2025 8:30 PM, Keith Thompson wrote:

olcott <polcott333@gmail.com> writes:

On 5/8/2025 6:49 PM, Keith Thompson wrote:

olcott <polcott333@gmail.com> writes:

 

His simulation is in fact a single-stepped x86 instruction simulation,
where the stepping of each x86 instruction is under the HHH's control.
HHH can continue stepping the simulation until its target returns, in
which case the situation is logically just like direct call, as you
have described.  Or HHH could step just 3 x86 instructions (say) and
then decide to return (aka "abort" its simulation).  Let's call that /
partial/ simulation in contrast with /full/ simulation which you've
been supposing.

A full simulation of infinite recursion?
I am only doing one tiny idea at a time here.

Yeah, so not a full simulation.
 

Didn't you know this?
It is incorrect for a simulating termination analyzer
to do a full simulation of a non-halting input.

In practice, the program will likely crash due to a stack overflow,
unless the compiler implements tail-call optimization, in which case
the program might just run forever -- which also means the
unnecessary return statement will never be reached.

Yes you totally have this correctly.
None of the dozens of comp.theory people could ever achieve that level
of understanding even after three years. That is why I needed to post
on comp.lang.c.

Everybody on comp.theory understands this much.

No one here ever agreed that when 1 or more instructions of DDD are
correctly simulated by HHH that DDD cannot possibly reach its own
"return" instruction.

That's wrong as written. HHH cannot simulate DDD returning in a
finite number of instructions, it takes infinitely many.
 

HHH can simulate 1 or more instructions of DDD,
this is not actually logically impossible.
When HHH does correctly simulate 1 or more
instructions of DDD then DDD never reaches its
"return statement" final halt state.

This conclusion relies on my understanding of what you've said about
your code, which I consider to be unreliable.

>
Hmm, did PO make it clear that when he says
     "..DDD correctly simulated by HHH cannot
      possibly REACH its own "return" instruction."
he is not talking about whether "DDD halts"?  [I.e. halts when run
directly from main() outside of a simulator.]  No, what he is talking
about is whether the /step-by-step partial simuation/ of DDD performed
by HHH proceeds as far as DDD returning.

>
When 1 or more steps of DDD are correctly simulated by HHH the simulated
DDD cannot possibly reach its "return" instruction (final halt state).
No one here has agreed to that. Not in several years of coaxing and
elaboration.

It's true for a finite number. Aborting is not correct simulation, even
if HHH did return that DDD halts.
 

Didn't you know this?
It is incorrect for a simulating termination analyzer
to do a full simulation of a non-halting input.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer