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

On 5/9/2025 10:47 AM, joes wrote:

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.
 

void DDD()
{
   HHH(DDD);
   return;
}
When 1 or more statements of DDD are correctly
simulated by HHH then this correctly simulated
DDD cannot possibly reach its own “return statement”.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer