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

On 5/1/25 4:15 PM, olcott wrote:

On 5/1/2025 10:14 AM, André G. Isaak wrote:

On 2025-04-30 21:50, olcott wrote:

On 4/30/2025 7:17 PM, André G. Isaak wrote:

>

You are still hopelessly confused about your terminology.
>
Computable functions are a subset of mathematical functions, and mathematical functions are *not* the same thing as C functions. Functions do not apply "transformations". They are simply mappings, and a functions which maps every pair of natural numbers to 5 is a perfectly legitimate, albeit not very interesting, function.
>
What makes this function a *computable function* is that fact that it is possible to construct a C function (or a Turing Machine, or some other type of algorithm) such as int foo(int x, int y) {return 5;} which computes that particular function; but the C function and the computable function it computes are entirely separate entities.

>
computes the sum of two integers
by transforming the inputs into an output.
int sum(int x, int y) { return x + y; }
>
Computes no function because it ignores its inputs.
int sum(int x, int y) { return 5; }

>
All you're demonstrating here is that you have no clue what a function is, nor, apparently, do you have any desire to learn.
>
André
>

 What I am explaining is that a halt decider
must compute the mapping FROM THE INPUTS ONLY
by applying a specific set of finite string
transformations to the inputs.

Right, it only gets to USE the input. The input does FULLY SPECIFY the algorithm of the program described by it, and thus all the information that defines what the direct execution
The limitation of what the decider can do has no bearing on the ability to ask the queastion. Since the question of the behavior is fully defined, and all the information to feed that definition is present, it is a fair question.
The fact that the decider just can't get the answer, and we can do this for ANY possible decider, the mapping is just shown to be uncomputable.

 int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
 Everyone assumes that it is correct to ignore
the required finite string transformations
that mandate DD correctly emulated by HHH
cannot possibly reach its own final halt state
no matter what of an infinite set of HHH's does.
 

And you just shows that you are a pathological liar, since it has been shown that HHH doesn't do the correct emuation that you claim.
This just shows that you concept of logic includes the right to lie about what you are doing, and thus your logic is just worthless.
Sorry, but that *IS* what you are showing, that you have no concept of what Truth or Logic actually is.