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

Op 10.mei.2025 om 05:17 schreef olcott:

On 5/9/2025 10:12 PM, Keith Thompson wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:

On 09/05/2025 03:23, Keith Thompson wrote:

Richard Damon <richard@damon-family.org> writes:

On 5/8/25 7:53 PM, olcott wrote:

[...]

void DDD()
{
     HHH(DDD);
     return;
}
We don't need to look at any of my code for me
to totally prove my point. For example when
the above DDD is correctly simulated by HHH
this simulated DDD cannot possibly reach its own
"return" instruction.

>
And thus not correctly simulatd.
>
Sorry, there is no "OS Exemption" to correct simulaiton;.

Perhaps I've missed something.  I don't see anything in the above
that
implies that HHH does not correctly simulate DDD.  Richard, you've read
far more of olcott's posts than I have, so perhaps you can clarify.
If we assume that HHH correctly simulates DDD, then the above code
is
equivalent to:
      void DDD()
      {
        DDD();
        return;
      }
which is a trivial case of infinite recursion.  As far as I can
tell,
assuming that DDD() is actually called at some point, neither the
outer execution of DDD nor the nested (simulated) execution of DDD
can reach the return statement.  Infinite recursion might either
cause a stack overflow and a probable program crash, or an unending
loop if the compiler implements tail call optimization.
I see no contradiction, just an uninteresting case of infinite
recursion, something that's well understood by anyone with a
reasonable level of programming experience.  (And it has nothing to
do with the halting problem as far as I can tell, though of course
olcott has discussed the halting problem elsewhere.)
Richard, what am I missing?

>
Depends on what you've picked up on.
>
Do you get that HHH's simulation is a /partial/ simulation?  HHH is
free to simulate a few x86 instructions of DDD, and then simply
abandon the simulation and return.  Since such a simulation is
obviously NOT equivalent to a direct call to DDD, and above you argue
that it is, I'd say you've missed that.

>
I have not read the vast majority of olcott's post here.  For most
of the recent discussion I had with him, there was no mention of
partial simulation.  olcott finally said something about simulating
just a few instructions, but at the same time he finally indicated
that understanding his arguments would require an understanding of
x86 machine and/or assembly language.  That's when I bailed out.
>
A "correct simulation", as I understand the term, would require fully
simulate the execution of DDD.  If DDD never halts, its simulation never
halts.  olcott seems to think that he's found a way around this that's
relevant to the Halting Problem, but I withdrew before getting to that
point.
>

 It only need be a correct simulation until HHH sees the
repeating pattern that would cause itself to never terminate.

Which it cannot see, because it is not there. It misses the part in the input that aborts and halts.
It seems very difficult for you to accept verifiable facts when they disturb your dreams.

 The best selling author of theory of computation textbooks
agreed that I could quote his agreement with my words.
 <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its
     input D until H correctly determines that its simulated D
     would never stop running unless aborted then
      H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
 

Why repaying this when it was explained that Sipser agreed to a vacuous statement, as there is no correct simulation.
It seems very difficult for you to accept verifiable facts when they disturb your dreams.