What does it mean to have a truth value of a 'nothing' type instance?

Question

I'm from a programming background, so please forgive me for asking programming-related logic questions. My question is this: Many things have a truth value, including true and false themselves. However, all objects that have a truth value are something, such as integers, objects, premises, …etc. My question is, is "nothing" true or false? "Nothing" can be interpreted as not being something, so is it eligible for a truth value test? Or is "nothing" actually something, and thus can have a truth value? If so, what is it?

In programming, all of this is rather simple: The object false is false, the object true is true, and the object null or None is false. For example, the following Python code:

>>> bool(True)
True
>>> bool(False)
False
>>> bool(None)
False

However, I'm seeking to understand this in a logical and philosophical way. Any ideas on this? I'll greatly appreciate any explanation. Thanks in advance!

---

Note: This is not a question about programming, it is in fact the opposite. I know how this question is approached, interpreted, and solved in computer science, but not in philosophy. I'm looking for a philosophical point of view on this.

Answer 1

First, welcome to PhilSE! You're in the right place, and though your question presents in the language of programming logic, logic, language, and computation are all intertwined: consider the Curry-Howard Correspondence, for instance.

Now, Mauro's comments are the most important. Objects, be they metaphysical or programmatic, do not have truth values; rather truth values are assigned to propositions or statements which express relationships. In natural language, we call this a "complete thought". So, "Bob" does not have a truth value, but "Bob is in the room" does. This assignment of a truth value is a form of philosophical judgement, and in Frege's Logic (SEP), it is indicated by a single turnstile. From the article:

The judgement stroke is perhaps the aspect of Frege’s logic, in both versions, that has been the subject of the most controversy. Simply put, the judgement stroke, in the logic of Begriffsschrift, transforms a judgeable content into a judgement... ⊢A...

Today in philosophy, we say that an indicative statement expresses a proposition which has assertoric force. The idea is that in a theory of truth, the language that expresses the state of affairs (as in the correspondence theory of truth, for instance) expresses an attitude of the thinker. The fancy term in philosophy is called the propositional attitude. From WP:

A propositional attitude is a mental state held by an agent or organism toward a proposition... In philosophy, propositional attitudes can be considered to be neurally-realized causally efficacious content-bearing internal states (personal principles/values)... Linguistically, propositional attitudes are denoted by a verb (e.g. believed) governing an embedded "that" clause, for example, 'Sally believed that she had won'.

So, it is possible to paraphrase truth conditional semantics using propositional attitudes. Thus, when someone claims 'Snow is white' is true, we can use the propositional attitude to say that 'Someone believes that "Snow is white" is true'. For computers, we can simply substitute run-time. bool(Nothing) can be expressed in the language of propositional attitude as 'The run-time system of the software evaluates "bool(Nothing)" to true.'

So, when a programmer tells a compiler to evaluate a statement in a for loop, what the run-time that the compiler's output operates on simply judges a statement it is processing to be true or false. So, let's say you write a iterative loop with an exit condition that the variable c must be less than 10 to continue to operate. When the run-time begins to execute the for loop, if c=9 and the condition is `c<10', internally, the run-time assigns true and then executes the loop code within its own scope. We can say 'The run-time evaluates that the branch conditional is true', which is a propositional attitude.

In programming language design, we often return truth values in ways that don't occur in natural language. Consider the use of returning a true in a function which conducts an operation: ExecuteSomeFubar(argument). Here, the run-time executes the associated procedure, and might return a true statement to allow the software to check the operational status of the procedure. It is the equivalent to the judgement OperatedSuccesfully(ExecuteSomeFubar(argument)). This allows the run-time to handle errors by explicitly using return types to indicate the status of execution in a distinct scope. Of course, more sophisticated programming languages include explicit constructs like try-catch-finally to manage separation of concerns.

Since procedures can be associated with Boolean types in software in accordance with the desires of the programmer, one is free to craft philosophical judgements as one sees fit. You cite as an example >>> bool(None) -> False. Here, bool() has been implemented to return false on the None type. Why false? Because it allows Python then, to use the None type as a synonym for false. The association of values of bools, ints, floats, custom user-types, etc. is specific to the design of the particular type system which allows us to execute code based conditionally on the associated type, as opposed to the value. For example, a judgement can be made based on values such as c==10 or it can be made based on type typeof(c). This greatly enhances the system of flow control.

Answer 2

"Schopenhauer makes use of Kant’s distinction between two kinds of nothing: the nihil privativum or privative nothing, and the nihil negativum or negative nothing. The former is nothing defined as the absence of something (e.g. shadow as absence of light, death as absence of life)." (Eugene Thacker, Darklife: Negation, Nothingness, and the Will-to-Life in Schopenhauer, p. 11)

It is this privative nothing that characterises Kant's "unconditioned necessity", which has the absence of conditioning.

"from the totality of conditions for thinking objects in general insofar as they can be given to me I infer the absolute synthetic unity of all conditions for the possibility of things in general; i.e., from things with which I am not acquainted as to their merely transcendental concept, I infer a being of all beings, with which I am even less acquainted through its transcendental concept, and of whose unconditioned necessity I can make for myself no concept at all. This dialectical syllogism I will call the ideal of pure reason." (Kant, Critique of Pure Reason, 1781/7, A340/B398)

Kant says he can make no concept of it because it is unconditioned. It is not a thinking object, it is the overall facility for thinking.

OP: "is "nothing" actually something, and thus can have a truth value? If so, what is it?"

Now we get into a tricky territory for language, where something is not a thing. The overall facility for thinking is being. Can we say being is a thing? Apparently not.

"'Being' cannot indeed be conceived as an entity; enti non additur aliqua natura: nor can it acquire such a character as to have the term "entity" applied to it. "Being" cannot be derived from higher concepts by definition, nor can it be presented through lower ones." (Heidegger, Being & Time, 1927, H. 4)

Upon which Jacques Derrida comments

"the expression Sein is not only an infinitive but a verbal substantive ... It consolidates [being] and makes it into something. ... Should we abandon a grammatical form that is so threatening for the right thinking of being, a thinking that is neither a concept nor a thinking of a being? ... What would happen if giving up on the grammatical form of the verbal substantive in philosophical discourse, we had to limit ourselves to the other forms? ... In that case, one would say: being? — I know nothing about it. I do not know what that means, primarily because I’ve never come across it and no one will ever come across it. The pre-comprehension Heidegger talks about at the beginning of Sein und Zeit is in this case merely an incomprehension. I understand what being means only when being comes to determine something or is determined by something, when I say I am, and you are, and he or it is, and so on." (Jacques Derrida, Heidegger: The Question of Being & History, 1964, p. 51–52)

So now we have nothing that is something, but is not a thing. Perhaps it should indeed have a truth value in its instance as a nihil privativum.

To clarify further the relation of nothing to being.

"The nothing is the "not" of beings, and is thus being, experienced from the perspective of beings. The ontological difference is the "not" between beings and being. Yet just as being, as the "not" in relation to beings, is by no means a nothing in the sense of a nihil negativum, so too the difference, as the "not" between beings and being, is in no way merely the figment of a distinction made by our understanding (ens rationis)." (Heidegger, 1949 preface to On the Essence of Ground in Pathmarks, p. 97)

Answer 3

The semantics of a language are defined by its use. In Python, the truth value of a bool (Boolean value) is itself: bool(True) is True, and bool(False) is False. We can think of truth values as answers to questions.

For values of other types, truthiness is determined by the .__bool__ magic method. We can think of this as the implicit question, when no question is explicitly asked. By convention, the implicit question in Python is some variation of "is anything there?".

• list.__bool__ asks: "Is the list non-empty?"
• set.__bool__ asks: "Is the set inhabited?"
• int.__bool__ asks: "Is the number non-zero?"

What should NoneType.__bool__ be? Which question should we ask? According to Python's conventions, we should ask "is anything there?". Is nothing anything? Signs point to 'no'.

---

This is, of course, a matter of convention. In Python, we have two truth values, and it's Pythonic to say that None is falsy. However, we could just as easily use a paraconsistent logic – like Nuel Belnap's four-valued logic, or IEEE 1164's nine-valued logic – in which it might be natural to assign None a different truth value.

As with many such questions, the answer is "it depends".

Answer 4

Philosophically/Logically speaking:

You can conclude anything from a false (=no) premise.

Sidenote: "anything" here refers to either case of a conclusio being "true" or "false".

Or in other words:

You can conclude anything from nothing.

Meaning, if you want to apply the "null" of programming languages to the real world, you would start from a false premise (an undefined premise, that is "nothing"). Thus the conclusions (=results drawn from that premise) can all be "true" or "false" and you wouldn't be able to tell, because your premise does not allow any "rules" to be deduced.

It is the subtle difference between an implication (works only from premise to conclusion, it cannot be reversed - but this would be the case needed when wanting a "null" premise) and an equivalence (works both ways, is reversible).

And therefore:

You can (only) conclude nothing from nothing.

See: Logical consequences on Wikipedia as a starting point for more information.

Answer 5

The question is ill-defined. Truth values are assigned to statements, propositions, and the like; "nothing" isn't a statement, proposition, or the like, so there is no standard definition which assigns it a truth value.

Some programming languages assign a truth value to various objects, but there is no way to understand this "in a logical and philosophical way," because this programming language feature is designed based on what will be most convenient for the programmer, not based on any kind of underlying logic or philosophy.

Answer 6

A rather unusual way to analyze this is to look through the lens of the Curry-Howard correspondence. Under this correspondence, types are equivalent to propositions. Individual instances are not normally considered to be propositions at all, but in the case of a unit type such as Python's NoneType, there's a tendency to conflate the type with the term (e.g. in Python type annotations, we usually write None and not NoneType, and many other languages don't even have a separate name for the type).

So now that we have a proposition, what is its truth value? Under the C-H correspondence, the unit type directly corresponds to a tautology - in other words, the C-H correspondence quite unambiguously assigns a value of "true" to any unit type. However, before you go filing bugs against Python and other languages for (mostly) treating unit as a false type, you need to understand what the C-H correspondence is all about.

In the C-H correspondence, a type corresponds to a true statement if it is an inhabited type - that is, if you can construct an instance of that type. In many languages, all types are constructible, so all types (that can be expressed) are "true." If an empty type does exist, in practice it will usually be either the bottom type or some other type derived from the bottom type (e.g. a function which returns bottom, a generic type with bottom as a parameter, etc.). Those types are genuinely false, because you cannot construct instances of them, or even write code which purports to do so (unless you do something unsound such as type-casting).

The argument of an if statement (or other control flow primitive) is usually not a type at all, but a term.* Under C-H, terms do not correspond to propositions, but to proofs. Specifically, the term is a proof that "the type of this term is inhabited" (the type must be inhabited for the term to exist). Unfortunately, this is more or less where our luck runs out. The C-H correspondence doesn't "see" a difference between the terms true and false, because they are both simple one-line proofs that bool (or whatever your language calls it) is inhabited. Obviously, we want if(true) to run the code guarded by the if, and we want if(false) to not run said code. Since C-H can't see any difference between those two lines of code, it is not usefully possible for C-H to tell you how an if statement should behave in general.

Does that make C-H useless? Well. It depends on who you ask. Quite a few proof assistants are really just programming languages with highly elaborate type systems. Coq is a good example of this design. This would not be possible without either C-H or some extension of it.

---

* This is a bit of a fudge. If we want to be strict, a "term" should be an entire function body, not just an individual value. In languages that look like the lambda calculus, there's no distinction between a value and the code which produces that value, but in just about every practically-used model of computation, it is possible to introduce variable names as desired and not just at function boundaries. When we add that capability to the language, the variable can be thought of as a "shorthand" for the underlying computation. Strictly that's only true for pure computations, but if we want to allow for impure computations, we either need to box them up into monads as Haskell does, or we need to allow the arbitrary use of variables to properly capture the happens-once semantics of impure computation.