Boolean Logic

Two values and three operators

Boolean logic is the algebra of a two-valued world. Every boolean value is exactly one of two things, true or false, with no third option and no in-between. That restriction is the point: because there are only two values, the behavior of every operation can be written out completely in a small table. The type is named for George Boole, the nineteenth-century mathematician who first treated logical reasoning as a kind of algebra.

Three basic operators combine boolean values. AND (also called conjunction) takes two operands and yields true only when both operands are true; if either one is false, the result is false. OR (inclusive disjunction) yields true when at least one operand is true, and false only when both operands are false. Note that this OR is inclusive: 'true OR true' is true, not false. NOT (negation) takes a single operand and yields its opposite, turning true into false and false into true. These three are enough to express any boolean function; other operators such as exclusive-or can be built from them.

Different languages spell the operators differently. Python writes them as the words and, or, not; many C-family languages write &&, ||, !. Mathematical logic uses the symbols ∧ (conjunction), ∨ (disjunction), and ¬ (negation). The names and symbols change, but the truth tables do not.

Truth tables: the complete specification

A truth table lists every possible combination of input values and the output for each. Because each operand is one of two values, an operator on two operands has exactly four input rows, and one operand has two. The tables below are the full definition of the operators.

AND: false AND false is false; false AND true is false; true AND false is false; true AND true is true. Only the last row is true. OR: false OR false is false; false OR true is true; true OR false is true; true OR true is true. Only the first row is false. NOT: NOT false is true; NOT true is false.

These tables are worth memorizing because they let you evaluate any expression mechanically. To evaluate a compound expression, resolve NOT first, then AND, then OR, unless parentheses say otherwise; this precedence order (NOT above AND above OR) is standard across mathematics and most programming languages. For example, in A OR B AND C, the AND is evaluated before the OR, so it means A OR (B AND C). When precedence is not obvious to a human reader, adding parentheses makes the intended grouping explicit and prevents a whole category of bugs.

Any boolean expression built from these operators can be fully checked by writing out its truth table: list every combination of the input variables, evaluate column by column, and read off the result. If two expressions produce identical output columns for every input row, they are logically equivalent and can be substituted for one another.

De Morgan's laws

Two equivalences, named for Augustus De Morgan, a contemporary of Boole in the nineteenth-century algebra-of-logic tradition, describe how negation distributes over conjunctions and disjunctions. The first law: NOT(A AND B) is equivalent to (NOT A) OR (NOT B). The second law: NOT(A OR B) is equivalent to (NOT A) AND (NOT B). In words, when you push a NOT inside a parenthesis, each operand gets negated and the operator flips: AND becomes OR, and OR becomes AND.

These laws are not intuitions to trust on faith; they are provable by truth table. Build the table for NOT(A AND B) and the table for (NOT A) OR (NOT B), and the two output columns match on all four rows, which is exactly what logical equivalence means. The worked example below does this.

De Morgan's laws matter in practice because programmers frequently need to negate a condition. Suppose a feature should run only when a user is 'not (logged in and verified)'. By the first law, that is the same as 'not logged in, or not verified', which is often easier to read and to reason about. Getting this transformation wrong, for instance by flipping the operands but forgetting to change AND to OR, is a classic logic error that produces code that looks correct but behaves backwards on some inputs.

Short-circuit evaluation and program conditions

Most languages evaluate AND together with OR using short-circuit semantics: they stop as soon as the result is determined. For AND, if the first operand is false, the whole expression is already false regardless of the second operand, so the second operand is never evaluated. For OR, if the first operand is true, the whole expression is already true, so the second operand is skipped. Python's documentation states this directly: and only evaluates its second argument if the first is true, and or only evaluates its second argument if the first is false.

Short-circuiting is not just an optimization; it changes what programs can safely express. A guard such as x != 0 and y / x > 2 relies on it: when x is zero, the first operand is false, so the division is never attempted and no divide-by-zero error occurs. Reordering the operands would break that protection. A related language detail worth knowing is that in Python and and or return one of their operands rather than a strict True or False, and not always returns True or False; the truth-table behavior still holds when the result is used as a condition.

All of this exists to serve program decisions. A conditional statement evaluates a boolean expression and runs one branch when the result is true and another when it is false; a loop re-evaluates a boolean expression to decide whether to continue. Because these tests sit at the fork of every decision, a small logic mistake changes the program's behavior for real inputs. Reading truth tables, respecting precedence, and applying De Morgan's laws are the tools that let you write conditions you can actually verify.