Re: HHH(DDD) computes the mapping from its input to HHH emulating itself emulating DDD --- anyone that says otherwise is a liar

On 11/17/24 9:35 PM, olcott wrote:

On 11/17/2024 8:26 PM, Richard Damon wrote:

On 11/17/24 8:44 PM, olcott wrote:

On 11/17/2024 4:03 PM, Richard Damon wrote:

On 11/17/24 3:49 PM, olcott wrote:

On 11/17/2024 1:56 PM, Richard Damon wrote:

On 11/17/24 1:36 PM, olcott wrote:

void DDD()
{
   HHH(DDD);
   return;
}
>
_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
>
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
>

>
Except your DDD *CAN'T BE EMULTATED* by *ANY* HHH, as it is IMPOSSIBLE to emulate the Call HHH per the x86 language from your input, as the data isn't tnere.
>

>
In patent law this is called incorporation by reference.

>
And you need to PRECISELY specify what you are referencing.
>
>

I referred to every element of an infinite set of encodings
of HHH. You already know that it is ridiculously stupid
that you suggest I should write them all down.

>
And thus admit that you are not talking sense, as each HHH that you think of creates a DIFFERENT program DDD
>

>
When each of them correctly emulates N instructions of its
input then N instructions have been correctly emulated. It
is despicably dishonest of you to say that when N instructions
have been correctly emulated that no instructions have been
correctly emulating.

>
No, it is dishonest for you to lie.
>
I never said that N instructions correctly emulated is no instructions correctly emulated, just that it isn't a correct emulation that provides the answer for the semantic property of halting, which requires emulating to the final state or an unbounded number of steps.
>

>
void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}
>
You are stupid liar. A smart liar would not be caught
in a lie with such a simple counter-example
THAT IS NEITHER EMULATED TO THE FINAL STATE NOR AN
UNBOUNDED NUMBER OF STEPS TO DETERMINE NON-HALT STATUS.
>

>
No, but it is the fact that it CAN be emulated for an unbounded number of steps that makes it non-halting.

>
Your rebuttals are stupid.
It cannot be emulated for an unbounded number of steps.
That is a stupid thing to say.

 So, you mean a UTM doesn't exist?