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 11:05 PM, olcott wrote:

On 11/17/2024 9:19 PM, Richard Damon wrote:

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?
>

 HHH is not a UTM you stupid nitwit.
 

Of course it isn't, which is why HHH's emulation doesn't define the behavior of the input.
I never said HHH was a UTM, that is just your insane mind imagining things.
You said it was impossible to emulate the input for an unbounded number of steps. That is just a LIE. That is exactly what a UTM would do when given Infinite_Recursion as an input.
The fact that HHH can't do that and return an answer is irrelevant in the real world.
You are just stuck in your incorrect subjective world where HHH is required to be the source of truth.
The thing that you can't seem to get into your thick skull is that the "meaning" of the input isn't defined by the decider, but by the processing (perhaps unbounded) of FULL emulation of the input.
This is true even if it is impossible for the emulator to do that.