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

Am Fri, 09 May 2025 10:08:40 -0500 schrieb olcott:

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.

HHH simulates DDD returning only in an infinite number of steps.

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.

It is incorrect for a simulating termination analyzer to do a full
simulation of a non-halting input.

Yes, that is why HHH cannot both be a decider and simulate correctly.
And then it goes further and guesses wrongly.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.