Re: Turing Machine computable functions apply finite string transformations to inputs

On 4/26/2025 12:22 PM, olcott wrote:

On 4/25/2025 5:09 PM, joes wrote:

Am Fri, 25 Apr 2025 16:46:11 -0500 schrieb olcott:

On 4/25/2025 11:54 AM, Richard Damon wrote:

On 4/25/25 12:31 PM, olcott wrote:

>

Once we understand that Turing computable functions are only allowed
to derived their outputs by applying finite string operations to their
inputs then my claim about the behavior of DD that HHH must report on
is completely proven.
>

Youy have your words wrong. They are only ABLE to use finite algorithms
of finite string operations. The problem they need to solve do not need
to be based on that, but on just general mappings of finite strings to
finite strings that might not be described by a finite algorithm.
The mapping is computable, *IF* we can find a finite algorith of
transformation steps to make that mapping.
>

There are no finite string operations that can be applied to the input
to HHH(DD) that derive the behavior of of the directly executed DD thus
DD is forbidden from reporting on this behavior.

 

Yes, there are, the operations that the processor executes. How did you
think it works?
>

 When you try to actually show the actual steps
instead of being stuck in utterly baseless rebuttal
mode YOU FAIL!
 _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]
 When any HHH emulates DD according to the finite
string transformation rules specified by the x86
language (the line of demarcation between correct
and incorrect emulation) no emulated DD can possibly
reach its final halt state and halt.
 

Category error.  There is one and only one algorithm HHH as defined in Halt7.c.  So your claim is that the emulation of algorithm DD by algorithm HHH does not reach a final state, so an answer of non-halting is correct.
int H1(void *p)
{
     void *state = NULL;
     int done = emulate_one_step(p, &state);
     if (!done) {
         return 0;
     } else {
         return 1;
     }
}
void foo()
{
    int x = 0;
    x++;
    x++;
    x++;
}
int main()
{
     H1(foo);
}
By the same logic, algorithm H1 cannot simulate algorithm foo to a final state, therefore H1(foo) == 0 is correct.
Agreed?