Re: HHH(DD) --- COMPUTE ACTUAL MAPPING FROM INPUT TO OUTPUT --- Trolls

On 4/22/2025 7:57 AM, joes wrote:

Am Tue, 15 Apr 2025 15:44:06 -0500 schrieb olcott:

On 4/15/2025 2:03 PM, dbush wrote:

On 4/15/2025 2:50 PM, olcott wrote:

On 4/15/2025 11:05 AM, dbush wrote:

On 4/15/2025 11:29 AM, olcott wrote:

 

*corresponding output to the input*
Not freaking allowed to look at any damn thing else besides the
freaking input. Must compute whatever mapping ACTUALLY EXISTS FROM
THIS INPUT.
>

So the algorithm HHH that you've implemented computes *some*
computable function, but it does not compute the halting function as
it is not computable.
>

*corresponding output to the input*
>

That doesn't refute anything I said.
>

You continue to stupidly insist that int sum(int x, int y) {return x +
y; }
returns 7 for sum(3,2) because you incorrectly understand how these
things fundamentally work.
>
It is stupidly wrong to expect HHH(DD) report on the direct execution of
DD when you are not telling it one damn thing about this direct
execution.

What else is it missing that the processor uses to execute it?
 

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]
libx86emu <is> a correct x86 processor and does emulate
its inputs correctly.
The key thing here is that everyone has consistently
flat out lied about the mapping from the above machine
code to the behavior of DD emulated by HHH including HHH
emulating itself emulating DD. They do this as a trollish
head game.
All of computation can be represented as finite string
transformation rules applied to finite strings.
   a function is computable if there exists an algorithm
   that can do the job of the function, i.e. given an input
   of the function domain it can return the corresponding output.
   https://en.wikipedia.org/wiki/Computable_function
Everyone here stupidly assumes that the output must
be derived from something THAT THE INPUT DOES NOT SAY.
This is stupidly incorrect and violates the definition
of a computable function.
HHH emulates DD including emulating itself emulating DD
according the the semantics of the x86 language. Disagreeing
with the semantics of the x86 language is as stupid as
disagreeing with arithmetic.
int sum(int x, int y) { return x + y; }
Believing that HHH should report on the direct
execution of DD is the same as is the same
as believing that sum(3,2) should report on
the sum of 5 + 2, stupidly incorrect.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer