1. Texts have finite length.
2. ____
3. Therefore, the halting problem does not impact machine translation.Given content that can be expressed in two languages in a text of finite length, you could in theory enumerate all the possible translated texts.
So, in general the non-physical is defined negatively. The physical is defined by physical limitations, i.e. the laws of physics and computation, and thus anything that surpasses those limitations is non-physical.
If you found something that could solve the halting problem and you're lucky enough to be able to prove it for this special case, that would just mean that the assumption that everything physical can be computed by a Turing machine is wrong. It works the same way with anything else that we think of as "impossible". If you observed an apple falling towards the sky that doesn't mean that the apple is non-physical, it just points to a serious flaw in our understanding of gravity. Experiments trump all physical theories.
Technically, we already recognize the world is non-physical. Materialists defined materialism to things bumping into each other. Now we know there are things like field effects, attraction, and action at a distance. So there is a non-bumping substrate that the bumping things exist within. Thus, strict physicalism is already known to be false.
The term physicalism was introduced a few decades after we figured out Maxwell's equations. If the philosophers defined it to mean things bumping into other things they were frankly poorly informed about the world we live in.
I think that the confusion here is that you're conflating "comprehension" with "execution". You can write out a set of instructions in English that describe a non-halting algorithm, but I don't have to determine whether the program you've described halts to understand what the algorithm does. And I certainly wouldn't need to determine that in order to translate the instructions into Spanish.
In general, understanding what a program does requires knowing whether it halts. For example, what does this program do when given input another_program?
if halts(another_program):
print "program halts."
else:
print "program does not halt."Given the lack of any proposals for how, even in theory, hypercomputation might be achieved in a physical system, and the lack of any empirical indication that humans are capable of hypercomputation, I would say it's much more than a conjecture. At the very least, it's an incredibly likely conjecture.
> For example, what does this program do when given input another_program?
It prints "program halts." if another_program halts, and prints "program does not halt." otherwise. I understand exactly what this program does, even though I can't tell you its output for an arbitrary input. And if I want to translate the above sentence into Spanish, I don't have to come anywhere near solving the halting problem to do so.
Consider the following program which does not involve the halting problem:
function (targetDigest)
i = new BigInt(0);
while(true) {
if (sha1(i.toBytes()) == targetDigest) {
print(i.toBinary());
}
i = i.plus(1);
}
}
But even if you can come up with sentences that require one to solve the halting problem to translate (and I'm still not convinced such sentences exist), it's another thing entirely to claim that those sentences come up in practice. This is a red herring when it comes to the feasibility of machine translation, because a good translator doesn't need to be able to cope with every valid sentence. It merely needs to cope with the set of sentences that humans actually care about.
If we knew everything that comes up in practice, translation and natural language processing would be a solved problem. Without this knowledge, then we need to look at the general picture, which is not solvable. So there is no automated way to understand all language, we have to always rely on a human in the loop to provide domain knowledge.
So unless you can give a specific example of a sentence that requires one to solve the halting problem to translate, I don’t think you’re saying anything hint meaningful. And if you can come up with such an example which people would actually use in practice, I’ll eat my hat.
if halts(input): return 1
else: return "Nope"
def a_func(input):
if eval(input) == 0:
return 1
else:
return "Nope"
In general, this is impossible, since eval(input) may not halt.
And assuming that "eval" is typed as String -> Any, there should be no problem automatically inferring the type signature of this function. I certainly didn't have to solve the halting problem to generate that signature.