Category-Error equivalents across fields
It is remarkable to note that from Aristotle on and through Kant, fundamental categories has been a staple of philosophy but philosophy has not dealt with category errors quite as well as other disciplines.
First let me tabulate how the basic notion of ‘category error’ looks elsewhere:
Area |
Name |
Philosophy |
Category Error |
CS |
Type Error |
Logic |
(non)WFF |
Physics |
Dimension error |
Math |
“Infinity error” |
Rhetoric |
Zeugma/Syllepsis |
The short answer
This is to your title question from the CS world:
- Category mistakes are type errors if your programming language is syntactically typed; in CS jargon in statically typed languages.
- In dynamically typed languages there is no such typing and so no category errors. This of course makes (what would be) a category error into a different kind of error, often more problematic for the programmer/user.
Under the assumption that the above is not very intelligible to folks without a CS background, I expand on this a bit below.
Pauli principle
In response to a particularly garbled physics paper,
Wolfgang Pauli said “(There is right wrong and) not even wrong”
A longer more detailed version runs: “What you said was so confused that one could not tell whether it was nonsense or not.”
Zeugma/Syllepsis
This is the lightest of the many fields but is an outlier because unlike all the others where it is unintended and undesired, here is is deliberately used for amusing effect:
- When he said, 'What in heavens', she made no reply, up her mind, and a dash for the door
More here
- Miss Bolo rose from the table considerably agitated, and went straight home, in a flood of tears and a Sedan chair
Dickens Pickwick papers
- The farmers in the valley grew potatoes, peanuts, and bored
Logic
What is going on here is that from Aristotle's excluded middle/non contradiction, through Boole and then Frege, logic has always been fundamentally binary. But that doesnt work in practice; sometimes we want to say More wrong than wrong!
Now you can if you wish flatten out your world into 2 saying everything that is not right is wrong. But this turns out to be way clumsier than it may appear.
Take logic. One could say eg.
P ∧ Q ⇒ P
is universally true (tautology);
P ∨ Q ⇒ P
is not. And
P ∧ ¬ P
is always false. But what about this?
P Q ⇒ P ¬∧
This is why logicians have come up with a ‘pre-pass’ to doing logic
called WFF. We make sure we dont have just any symbol mishmash but a
subset which has passed a syntactic sanity check. That sanity check
is described once in the book/lecture and then assumed to always be cleared in all further discussions.
CS
CS has taken this to the most refined level in the model of the compiler pipeline.
And at every stage in the pipeline what is processed has passed the sanity check of the earlier stages. Using the logic WFF-paradigm at each stage a putative formula, which may or may not be well formed, the non well formed case is filtered out. IOW at every stage the universal set of formulas is subsetted to a smaller guaranteed not not-even-wrong set for the next stage.
Of these the type-analyse phase comes closest to philosophy category errors, although as pointed out above every stage can be taken to filter category errors, just that the categories are different at each stage.