Truth Table Generator
Truth Table Generator
Quick insert:
Use variables A-Z. Operators: ∧ & AND, ∨ | OR, ¬ ! ~ NOT, → -> IMPLIES, ↔ <-> BICONDITIONAL, ⊕ ^ XOR, ↑ NAND, ↓ NOR
Separate multiple expressions with commas for a combined table.
Examples:
Specify column order as comma-separated variables. Leave blank for alphabetical.
Enter a Boolean Expression
Type a logical formula using variables A-Z and operators (∧ ∨ ¬ → ↔ ⊕), then click Generate Table or use the examples above.
Generate complete truth tables for any Boolean expression instantly
A truth table is one of the most fundamental tools in logic, mathematics, computer science, and digital circuit design. It provides a systematic way to enumerate every possible combination of truth values for a set of variables and shows how a logical expression evaluates under each combination. Whether you are a student studying discrete mathematics, an engineer designing digital circuits, a programmer debugging conditional logic, or a philosopher analyzing arguments, a truth table gives you a complete, unambiguous picture of how a Boolean formula behaves. Our Truth Table Generator makes this process effortless. Simply type — or click to insert — a Boolean expression using variables (A, B, C, …) and operators such as AND (∧), OR (∨), NOT (¬), XOR (⊕), IMPLIES (→), BICONDITIONAL (↔), NAND (↑), and NOR (↓). The tool instantly builds the complete 2ⁿ truth table, one row for every possible assignment of true and false to the variables, and evaluates your expression across all combinations. You can also view intermediate sub-expression columns step-by-step, which is invaluable for understanding how complex nested formulas are evaluated. Beyond the raw table, the generator automatically classifies your expression: a tautology is always true regardless of inputs — the classic example is A ∨ ¬A (the Law of Excluded Middle); a contradiction is always false, like A ∧ ¬A; and a contingency is neither — it is true for some assignments and false for others. This classification is displayed prominently so you can immediately understand the nature of your formula. The tool also computes the Disjunctive Normal Form (DNF) and Conjunctive Normal Form (CNF) of your expression. DNF is the OR of AND-clauses derived from each row where the expression is true — it lets you re-write any formula in a standardized 'sum of products' form. CNF is the AND of OR-clauses derived from rows where the expression is false — the 'product of sums' form. Both are canonical representations widely used in logic simplification, SAT solvers, and digital circuit synthesis. Minterm and Maxterm notation is displayed for expressions with mixed results. Minterms (Σm) index the rows where the output is 1; maxterms (ΠM) index rows where it is 0. These are standard notations used in Karnaugh-map simplification and in describing hardware logic in a technology-independent way. Operator input is flexible — you can use Unicode symbols (∧, ∨, ¬, →, ↔, ⊕, ↑, ↓) or type familiar ASCII equivalents such as & or && for AND, | or || for OR, ! or ~ for NOT, -> or => for IMPLIES, and <-> or <=> for BICONDITIONAL. English keywords AND, OR, NOT, XOR, NAND, NOR are also accepted. The quick-insert button bar above the text field lets you click to add any symbol without needing to know its keyboard shortcut. For exploring different scenarios, pre-loaded example expressions cover the most commonly studied formulas: simple implication, the Law of Excluded Middle (tautology), Contradiction, De Morgan's Law, Hypothetical Syllogism, and exclusive-or. Clicking any example loads it instantly. You can also control output format (True/False vs 1/0) and row ordering (false-first or true-first) to match your textbook or course conventions. The results panel includes a donut chart showing the ratio of true-to-false rows at a glance, providing immediate visual intuition about satisfiability. Copy the table to clipboard in tab-separated format for pasting into spreadsheets, or download it as a CSV file for further processing. All calculation happens entirely in your browser — no data is sent to any server, making this tool fast, private, and available offline once loaded.
Understanding Truth Tables and Boolean Logic
What Is a Truth Table?
A truth table is a mathematical table that lists all possible combinations of truth values (True/False or 1/0) for a set of propositional variables and shows the resulting truth value of one or more logical expressions for each combination. For n variables, the table has exactly 2ⁿ rows — one for each unique assignment. Truth tables were popularized by Ludwig Wittgenstein in the Tractatus Logico-Philosophicus (1921) and by Emil Post, and remain a cornerstone of classical propositional logic, digital electronics, and theoretical computer science. They provide a complete, exhaustive method for determining the logical properties of any Boolean expression without relying on algebraic manipulation.
How Are Truth Tables Generated?
The generator works in three stages. First, the expression is tokenized — split into a sequence of tokens representing variables, operators, and parentheses. Multiple input notations (∧, &, &&, AND) are normalized to canonical operator types. Second, a recursive descent parser applies operator precedence rules (NOT binds tightest, followed by AND, NAND, NOR, XOR, OR, IMPLIES, and BICONDITIONAL at the lowest precedence) to build an Abstract Syntax Tree (AST). Parentheses override precedence as expected. Third, for each of the 2ⁿ row assignments, the AST is evaluated recursively: variable nodes look up the current assignment; operator nodes apply their Boolean function to child results. Sub-expression columns are generated by evaluating each intermediate AST node separately.
Why Does This Matter?
Truth tables serve critical roles across many disciplines. In digital electronics and hardware design, Boolean expressions map directly to logic gate circuits; truth tables verify that a circuit implements the intended function. In software engineering, understanding logical expressions prevents bugs in conditional statements, short-circuit evaluation, and access control rules. In discrete mathematics and logic courses, truth tables are the standard proof method for demonstrating tautologies, contradictions, logical equivalences, and argument validity. In artificial intelligence and SAT solving, detecting satisfiability (whether any assignment makes a formula true) is a fundamental computational problem — P versus NP hinges on whether SAT can be solved efficiently. Understanding these concepts builds a foundation for algorithm analysis, cryptography, and formal verification.
Limitations and Practical Considerations
The main limitation of truth tables is exponential growth: n variables require 2ⁿ rows. With 8 variables you get 256 rows, which is still manageable; with 10 variables you get 1,024 rows. For practical circuit design or SAT problems with dozens of variables, algorithmic approaches (resolution, DPLL, BDD, K-map minimization) are necessary rather than exhaustive enumeration. This tool supports up to 8 variables to maintain usability on screen. Another practical consideration is that truth tables verify correctness but do not minimize expressions — use Karnaugh maps or the Quine-McCluskey method to find simplified equivalent expressions. The DNF and CNF outputs from this tool can serve as starting points for minimization. Also note that truth tables apply to classical two-valued logic; other logics (fuzzy logic, three-valued Łukasiewicz or Kleene logic) have different semantics not covered here.
Boolean Logic Formulas
Conjunction (AND)
p ∧ q — true only when both p and q are true
The AND operator returns true if and only if both operands are true. In digital circuits, this corresponds to an AND gate. In programming, it is the && operator.
Disjunction (OR)
p ∨ q — true when at least one of p or q is true
The OR operator returns true if either or both operands are true. It is false only when both operands are false. Corresponds to an OR gate in digital logic.
Material Implication
p → q ≡ ¬p ∨ q — false only when p is true and q is false
Implication states 'if p then q.' It is false only when the antecedent (p) is true but the consequent (q) is false. Logically equivalent to ¬p ∨ q.
De Morgan's Laws
¬(p ∧ q) ≡ ¬p ∨ ¬q and ¬(p ∨ q) ≡ ¬p ∧ ¬q
De Morgan's laws allow converting between AND and OR by distributing negation. Essential for simplifying Boolean expressions and designing equivalent logic circuits.
Logic Reference Tables
Logic Operator Truth Tables
Complete truth values for all standard binary logic operators with two variables p and q.
| p | q | AND (p∧q) | OR (p∨q) | XOR (p⊕q) | IMPLIES (p→q) | BICONDITIONAL (p↔q) | NAND (p↑q) | NOR (p↓q) |
|---|---|---|---|---|---|---|---|---|
| T | T | T | T | F | T | T | F | F |
| T | F | F | T | T | F | F | T | F |
| F | T | F | T | T | T | F | T | F |
| F | F | F | F | F | T | T | T | T |
Boolean Algebra Laws
Fundamental identities and laws used to simplify Boolean expressions in logic and circuit design.
| Law | AND Form | OR Form |
|---|---|---|
| Identity | p ∧ T = p | p ∨ F = p |
| Domination | p ∧ F = F | p ∨ T = T |
| Idempotent | p ∧ p = p | p ∨ p = p |
| Complement | p ∧ ¬p = F | p ∨ ¬p = T |
| Commutative | p ∧ q = q ∧ p | p ∨ q = q ∨ p |
| Associative | (p ∧ q) ∧ r = p ∧ (q ∧ r) | (p ∨ q) ∨ r = p ∨ (q ∨ r) |
| Distributive | p ∧ (q ∨ r) = (p ∧ q) ∨ (p ∧ r) | p ∨ (q ∧ r) = (p ∨ q) ∧ (p ∨ r) |
| De Morgan's | ¬(p ∧ q) = ¬p ∨ ¬q | ¬(p ∨ q) = ¬p ∧ ¬q |
| Absorption | p ∧ (p ∨ q) = p | p ∨ (p ∧ q) = p |
Worked Examples
Generate Truth Table for (p ∧ q) → r
Evaluate the compound expression (p ∧ q) → r for all possible truth value assignments of three variables.
Three variables produce 2³ = 8 rows in the truth table
First evaluate the sub-expression p ∧ q for each row
Then evaluate (p ∧ q) → r: implication is false only when antecedent is true and consequent is false
p ∧ q is true only when p = T and q = T (rows where both are true)
The overall expression is false only when p = T, q = T, and r = F
All other 7 rows evaluate to true
The expression (p ∧ q) → r is a contingency — it is true for 7 of 8 rows and false only when p = T, q = T, r = F. It is not a tautology because there exists at least one false row.
Verify De Morgan's Law: ¬(p ∧ q) ≡ ¬p ∨ ¬q
Generate truth tables for both ¬(p ∧ q) and ¬p ∨ ¬q to confirm they produce identical outputs.
Two variables produce 2² = 4 rows
Row 1: p=T, q=T → p∧q=T → ¬(p∧q)=F; ¬p=F, ¬q=F → ¬p∨¬q=F ✓
Row 2: p=T, q=F → p∧q=F → ¬(p∧q)=T; ¬p=F, ¬q=T → ¬p∨¬q=T ✓
Row 3: p=F, q=T → p∧q=F → ¬(p∧q)=T; ¬p=T, ¬q=F → ¬p∨¬q=T ✓
Row 4: p=F, q=F → p∧q=F → ¬(p∧q)=T; ¬p=T, ¬q=T → ¬p∨¬q=T ✓
Both expressions produce identical truth values (F, T, T, T) for all four input combinations, confirming De Morgan's Law: ¬(p ∧ q) is logically equivalent to ¬p ∨ ¬q.
How to Use the Truth Table Generator
Enter Your Expression
Type a Boolean expression in the text field using variables A through Z. You can type symbols directly (∧, ∨, ¬) or use ASCII equivalents (&, |, !, ->, <->). Click the operator buttons above the text field to insert symbols without needing Unicode keyboard shortcuts. Or click any pre-loaded example to start immediately.
Configure Output Options
Choose your preferred output format — True/False or binary 1/0 — to match your course or textbook. Toggle row ordering between 'false-first' (000…) and 'true-first' (111…). Enable or disable sub-expression columns to see the step-by-step evaluation of nested sub-formulas in intermediate columns.
Read the Truth Table
The table appears instantly with one row per input combination. Variable columns show each assignment; sub-expression columns (if enabled) show intermediate evaluations; and the final column shows the overall result, color-coded green for True and red for False. The classification badge at the top tells you immediately whether the expression is a tautology, contradiction, or contingency.
Export and Use Results
Click 'Copy' to copy the table to your clipboard in tab-separated format for pasting into spreadsheets or documents. Click 'CSV' to download a CSV file. Note the DNF and CNF representations for logic simplification work, and the minterm/maxterm indices (Σm / ΠM) for Karnaugh map entry or canonical Boolean representation.
Frequently Asked Questions
What is the difference between a tautology, contradiction, and contingency?
A tautology is a logical formula that evaluates to TRUE for every possible assignment of its variables — for example, A ∨ ¬A (the Law of Excluded Middle) is always true regardless of whether A is true or false. A contradiction is the opposite: it evaluates to FALSE for every assignment — A ∧ ¬A is the classic example. A contingency is neither: it is true for at least one assignment and false for at least one other. Most real-world logical expressions are contingencies. Tautologies are especially useful in logic because they represent universally valid reasoning patterns and are the basis of logical inference rules.
What operators are supported and how do I type them?
The generator supports AND (∧, &, &&, the word AND), OR (∨, |, ||, OR), NOT (¬, !, ~, NOT), XOR (⊕, ^, XOR), NAND (↑, NAND), NOR (↓, NOR), IMPLIES (→, ->, =>, the word IMPLIES), and BICONDITIONAL (↔, <->, <=>, the word BICONDITIONAL). You can type ASCII equivalents directly on any keyboard — for example, 'A -> B' for implication, 'A && B' for conjunction, '!A' for negation. The quick-insert buttons at the top of the input card let you click to insert Unicode symbols. You can also use lowercase letters — they are automatically converted to uppercase variable names.
What does DNF (Disjunctive Normal Form) mean?
Disjunctive Normal Form (DNF) is a standardized way of writing a Boolean expression as an OR of AND-clauses, where each clause is a conjunction of literals (a variable or its negation). Every Boolean expression has an equivalent DNF — the generator derives it by looking at each row where the output is TRUE and constructing an AND-clause that is satisfied only by that row's variable assignment. The DNF is useful because it makes satisfiability trivial to check (an expression in DNF is satisfiable if and only if it has at least one clause), and it is the sum-of-products (SOP) form used widely in digital circuit design and logic minimization tools like Karnaugh maps.
What is the maximum number of variables supported?
The Truth Table Generator supports up to 8 variables, producing a maximum of 256 rows. This limit is chosen to keep the table manageable on screen — with more than 6 variables (64+ rows) the table can become quite long on a mobile device. The generator will display a notice when you exceed 64 rows. If you need to analyze expressions with more variables for academic or engineering purposes, consider using a dedicated SAT solver or logic synthesis tool that uses more efficient methods than exhaustive enumeration. For most textbook exercises, 4 variables (16 rows) or fewer is typical.
How is operator precedence applied?
The parser applies standard logic operator precedence from highest to lowest: NOT binds most tightly (it applies to the immediately adjacent atom or parenthesized group), then AND, then NAND, then NOR, then XOR, then OR, then IMPLIES (→), and finally BICONDITIONAL (↔) at the lowest precedence. This means A ∧ B ∨ C is parsed as (A ∧ B) ∨ C — AND binds before OR. You can always override precedence with parentheses: (A ∨ B) ∧ C forces OR to be evaluated first. When in doubt, add parentheses for clarity — this is good practice in both logic and programming.
What are minterms and maxterms?
Minterms and maxterms are canonical forms used in Boolean algebra and digital circuit design. A minterm for n variables is a conjunction (AND) of all n variables (or their negations) that evaluates to TRUE for exactly one row of the truth table. The minterm index is the binary number formed by the row's variable assignments. The set of minterms where the expression is TRUE defines the expression in sum-of-minterms form (Σm). Conversely, a maxterm evaluates to FALSE for exactly one row; the product-of-maxterms form (ΠM) lists the rows where the expression is FALSE. Both representations are equivalent and interchangeable; they are the starting point for Karnaugh-map minimization and Quine-McCluskey tabulation.
Related Tools
Probability Calculator
Calculate probabilities for logical events and compound conditions.
Venn Diagram Generator
Visualize set operations (union, intersection, complement) that correspond to logical OR, AND, and NOT.
Equation Solver
Solve algebraic equations, complementing Boolean logic with numerical problem-solving.
Algebra Calculator
Simplify and evaluate algebraic expressions alongside Boolean algebra work.
Online Calculator
General-purpose calculator for arithmetic and scientific computations.