Re: Computing the mapping from the input to HHH(DD) --- REFUTES INCORRECT REQUIREMENTS

On 5/10/25 11:25 AM, olcott wrote:

On 5/10/2025 2:33 AM, Mikko wrote:

On 2025-05-09 16:25:12 +0000, olcott said:
>

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”.
(final halt state)

>
That one or more statements of DDD are correctly simulated does not
mean that DDD is correctly simulated.
>

 It is stipulated that when one or more statements
of DDD are correctly simulated that one or more
statements of DDD are correctly simulated.

And it is

 It is ridiculously stupid to require a simulating
termination analyzer to continue to simulate a non
terminating input.

Maybe to you, but that *IS* the definition, After all, the definition of a correcxt emulation is to EXACTLY reproduce the behavior of the input, and if that would never stop, the emulation must never stop.

 

That one or more cents of a debt is correctly paid does not mean
that the debt is correctly paid.
>

 My point is that there are no conditions where
DDD could be correctly simulated by HHH such that
DDD reaches its own "return" statement.

But only because no HHH can exist that can do the correct emulation of your stipulated input.
And when you add in the code of HHH, so it can be emulated, the only HHH that does the correct eumulation, is given the version DDD that uses it, and that will be non-hating, but every other HHH was given a DIFFERENT DDD, paired with itself, which is different that the one that never aborts, and thus can have different behavior.

 <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
 Simulating termination analyzers continue to simulate
until D simulated by hypothetical H (that does not abort)
*would never stop running unless aborted*
 

Until ORIGINAL D simulate by hypothetical H, would have the hypothetical H see D use the ORIGINAL H emulating the ORIGINAL D for a bit, then abort its emulation (since that is what it does) and then return to D and then D will halt.
Your problem is you LIE and change the code of D.
Of course, you forced yourself to lie, becuase you system just can't create the test case because it stipulates what H is so it can't be changed.
That is like stipulating x to be 1, and then asking what happens if x is 0, and using properties based on the stipulation.
You are just proving you are just a pathological liar that just doens't understand how truth works.