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

On 4/28/2025 4:14 AM, Mikko wrote:

On 2025-04-26 15:59:39 +0000, olcott said:
 

On 4/26/2025 3:19 AM, Mikko wrote:

On 2025-04-25 16:31:58 +0000, olcott said:
>

On 4/25/2025 3:46 AM, Mikko wrote:

On 2025-04-24 15:11:13 +0000, olcott said:
>

On 4/23/2025 3:52 AM, Mikko wrote:

On 2025-04-21 23:52:15 +0000, olcott said:
>

Computer Science Professor Eric Hehner PhD
and I all seem to agree that the same view
that Flibble has is the correct view.

>
Others can see that their justification is defective and contradicted
by a good proof.
>
Some people claim that the unsolvability of the halting problem is
unproven but nobody has solved the problem.

>
For the last 22 years I have only been refuting the
conventional Halting Problem proof.

>
Trying to refute. You have not shown any defect in that proof of the
theorem. There are other proofs that you don't even try to refute.

>
Not at all. You have simply not been paying enough attention.
>
Once we understand that Turing computable functions are only
allowed

>
Turing allowed Turing machines to do whatever they can do.

>
Strawman deception error of changing the subject away
from computable functions.

 Attempt to deceive by a false claim. The term "computable function" is
defined in terms of Turing machines so Turing machines are on topic.
 

Since there is no universally agreed upon definition
of the Turing Machine language it is impossible to
provide the 100% concrete details in this Turing
Machine language.
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Form bottom of page 2, (encoded more simply)
https://www.liarparadox.org/Linz_Proof.pdf
When embedded_H applies the finite string transformation
rules specified by the above template IT IS clear that
the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach is final state
of ⟨Ĥ.qn⟩
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation
Because none of the details are shown between state
transitions it is not a clear as the x86 example.
_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 we apply the finite string transformation rules specified
by the x86 language to the input to HHH(DD) WE ONLY GET THAT
DD DOES NOT HALT.

Turing Machine Computable Functions are not allowed
to output anything besides the result of applying
finite string transformations to their input.

 A Turing Machine Computable function is allowed and required to output
the value of the function for the given argument and nothing else.
 

Yes and it must do that by applying finite string
transformation rules to this input.
When we apply the finite string transformation rules specified
by the x86 language to the input to HHH(DD) WE ONLY GET THAT
DD DOES NOT HALT.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer