Enter any Boolean expression and this Boolean Algebra Calculator simplifies it to its minimal form, builds a complete truth table, and shows the exact law applied at every step — using AND, OR, NOT, XOR, NAND, NOR, and XNOR. It supports standard symbolic notation (·, +, ‘, ⊕) as well as plain-text input like “NOT (A AND B) OR C,” so you don’t need to memorize special syntax to get a correct simplification.
Boolean Algebra Calculator
Simplify expressions · Generate truth tables · Step-by-step solutions · Export PDF
De Morgan's LawsAbsorptionComplementIdentityIdempotentSOP / POS
Enter Boolean Expression
Press Enter or click Calculate
Quick Insert Operators
Supported Syntax & Examples
Operators
AND·*& | Logical AND |
OR+| | Logical OR |
NOT!~' | Logical NOT |
XOR^⊕ | Exclusive OR |
NAND | Not AND |
NOR | Not OR |
XNOR | Exclusive NOR |
Examples
related education calculators
What This Boolean Algebra Calculator Does
This is a boolean expression calculator built for anyone working through digital logic design, discrete math, or an intro computer science course. Type in an expression, and the tool acts as a full boolean algebra solver: it parses the expression, applies simplification laws in the correct order, and outputs the minimal equivalent form alongside a truth table showing every possible input combination.
Unlike a plain arithmetic calculator, a boolean calculator works with only two values — true (1) and false (0) — combined using logical operators instead of arithmetic ones. That makes it the right tool for digital circuit design, computer science coursework, and any situation where you need to reduce a complex logical statement to its simplest, gate-efficient form.
Supported Operators and Syntax
The calculator recognizes both symbolic and word-based input, so expressions like A·(B + C)’ and NOT (A AND B) OR C are both valid:
Operator | Meaning | Accepted Symbols |
AND | Logical AND | · * & |
OR | Logical OR | + | |
NOT | Logical NOT | ‘ ! ~ |
XOR | Exclusive OR | ^ ⊕ |
NAND | Not AND | typed as NAND |
NOR | Not OR | typed as NOR |
XNOR | Exclusive NOR | typed as XNOR |
This flexible parsing is what makes it a genuine NAND NOR XOR XNOR logic calculator rather than a tool limited to basic AND/OR/NOT combinations — a common gap in simpler online simplifiers.
How Boolean Expression Simplification Works
Every simplification this boolean algebra simplification calculator performs is grounded in a fixed set of algebraic identities. The calculator doesn’t guess at a shorter form — it applies these laws in sequence, the same way a student would on paper, and reports which law justified each step.
Boolean Algebra Laws Reference Table
Law | Rule | Example |
Identity Law | A + 0 = A, A · 1 = A | Removes redundant constants |
Idempotent Law | A + A = A, A · A = A | Collapses repeated terms |
Complement Law | A + A’ = 1, A · A’ = 0 | Resolves a variable against its own negation |
Double Negation | (A’)’ = A | Cancels a double NOT |
Commutative Law | A + B = B + A | Reorders terms freely |
Distributive Law | A · (B + C) = A·B + A·C | Expands or factors expressions |
Absorption Law | A + A·B = A | Removes a term fully “absorbed” by another |
De Morgan’s Theorem | (A·B)’ = A’ + B’, (A+B)’ = A’·B’ | Pushes NOT across AND/OR, flipping the operator |
Absorption is one of the more commonly misunderstood identities: A + A·B = A because if A is already true, the entire expression is true regardless of B — so the A·B term contributes nothing extra and can be dropped. De Morgan’s theorem is the identity most students reach for when negating a compound expression, since it converts a NOT-of-AND into an OR-of-NOTs (and vice versa) rather than requiring the expression to be rebuilt from scratch.
Worked Example 1: Simple Distributive Simplification
Expression: A·(B + C)
- Distributive Law applied: A·(B + C) = A·B + A·C
- No further reduction is possible — both terms are already in simplest form.
Result: A·B + A·C (equivalent, expanded form — useful when converting to sum-of-products)
Worked Example 2: Absorption Simplification
Expression: A + A·B
- Absorption Law applied directly: A + A·B = A, since the second term is redundant whenever A alone determines the outcome.
Result: A
This example matters because it’s the single most common case where beginners over-simplify manually and get it wrong by trying to factor instead of recognizing the absorption pattern.
Worked Example 3: De Morgan's Theorem on a Compound Expression
Expression: (A·B)’
- De Morgan’s Theorem applied: (A·B)’ = A’ + B’
- The result is already fully expanded — no further reduction available.
Result: A’ + B’
Worked Example 4: Multi-Step Consensus Simplification
Expression: A + A’·B
- Consensus-style reduction: A + A’·B = A + B, because whenever A is false, the A’·B term determines the outcome via B, and whenever A is true, the whole expression is already true — so the A’ factor can be eliminated.
Result: A + B
This is a slightly more advanced case than pure absorption, and it’s exactly the kind of multi-step reduction a boolean logic simplifier needs to handle correctly to be genuinely useful past introductory homework problems.
Generating a Truth Table from a Boolean Expression
Alongside simplification, the calculator builds a complete truth table for any input expression — every possible combination of 0s and 1s for each variable, paired with the resulting output. For a two-variable expression like A·(B + C), the table lists all four input rows (or eight, for three variables); the tool scales automatically as more variables are added.
A truth table serves two purposes: it verifies that the simplified expression is logically equivalent to the original (same output for every input row), and it provides the raw data needed to derive canonical forms like SOP and POS.
Converting Truth Tables to SOP and POS
Once a truth table is generated, it can be converted into two standard canonical forms:
- Sum of Products (SOP): built by OR-ing together one AND term for every row where the output is 1 (each of these terms is a minterm).
- Product of Sums (POS): built by AND-ing together one OR term for every row where the output is 0 (each of these terms is a maxterm).
SOP is generally easier to read and implement directly with AND-OR gate logic, while POS is preferred when the majority of output rows are 0, since it produces fewer, shorter terms in that case.
Karnaugh Map and Quine-McCluskey Minimization
For expressions with more variables, two standard minimization methods take over where basic algebraic simplification becomes error-prone by hand:
- Karnaugh map (K-map) minimization groups adjacent 1s (or 0s) in a grid laid out so that adjacent cells differ by exactly one variable, letting you visually identify the largest possible groupings and read off a minimal SOP or POS directly.
- The Quine-McCluskey method achieves the same minimal result algorithmically rather than visually — it’s the standard choice once an expression has too many variables to grid out reliably (typically five or more), since K-maps become difficult to draw and read correctly past four variables.
Both methods are aimed at the same goal as manual algebraic simplification: reducing gate count and circuit complexity while preserving the exact same logical output.
Common Mistakes When Simplifying Boolean Expressions
- Misapplying De Morgan’s theorem — forgetting to flip the operator (AND becomes OR, or vice versa) when distributing a NOT across a compound term.
- Over-factoring instead of recognizing absorption — trying to algebraically expand A + A·B rather than seeing that it collapses to A directly.
- Dropping a variable’s complement incorrectly — treating A + A’ as A instead of correctly resolving it to 1.
- Confusing NAND/NOR with plain AND/OR negation order — NAND is “NOT (A AND B),” not “(NOT A) AND (NOT B)”; the negation applies to the whole expression, not each variable individually.
- Skipping verification — accepting a simplified form without checking it against a truth table, which is the fastest way to catch an error before using the expression in an actual circuit design.
How to Verify Your Simplified Expression
The most reliable check is a side-by-side truth table comparison: generate the truth table for the original expression and for the simplified result, and confirm every output row matches exactly. If even one row differs, the simplification contains an error — usually a misapplied law rather than an arithmetic mistake, since Boolean algebra has no arithmetic in the traditional sense.
Building a Logic Circuit from a Boolean Expression
Each operator in a simplified Boolean expression maps directly to a physical logic gate: AND terms become AND gates, OR terms become OR gates, and a NOT becomes an inverter placed on the relevant input line. Because gate count and circuit complexity scale directly with the number of terms in the expression, simplifying the expression first — before drawing the circuit — is standard practice in digital electronics and directly reduces the number of gates required.
Minterms, Maxterms, and Boolean Functions
A minterm is a product term (AND of all variables, each either true or complemented) that equals 1 for exactly one row of the truth table. A maxterm is the OR-based equivalent, equaling 0 for exactly one row. Every Boolean function can be expressed as a sum of its minterms or a product of its maxterms — this is precisely what SOP and POS forms represent, and it’s the foundation both K-map and Quine-McCluskey minimization build on.
Tautology and Contradiction Checks
A tautology is an expression that evaluates to 1 (true) for every possible input combination — for example, A + A’, which is always true regardless of A’s value. A contradiction is the opposite: an expression that evaluates to 0 for every input, such as A · A’. The calculator’s truth table output makes both cases immediately visible: an all-1s output column confirms a tautology, and an all-0s column confirms a contradiction.
Frequently Asked Questions (FAQ)
Apply Boolean algebra laws — starting with the ones that reduce the term count fastest, such as absorption or complement — one at a time, and confirm the result against a truth table. This calculator performs the same sequence automatically and shows which law justified each step.
List every possible combination of 0s and 1s for the expression's variables, then evaluate the expression for each row. A three-variable expression produces eight rows; each additional variable doubles the row count.
For SOP, OR together the minterms from every row where the output is 1. For POS, AND together the maxterms from every row where the output is 0.
Adjacent 1s (or 0s) in the K-map grid are grouped in powers of two, and each group is converted into a single simplified term — larger groups produce shorter, more minimal terms.
It's a tabular, algorithmic alternative to K-maps that systematically combines minterms differing by one variable, used when an expression has too many variables to minimize reliably by hand or by grid.
Commonly: identity, idempotent, complement, double negation, commutative, distributive, absorption, and De Morgan's theorem — applied in whatever order reduces the expression fastest.
DNF (Disjunctive Normal Form) is an OR of AND terms, structurally the same as SOP. CNF (Conjunctive Normal Form) is an AND of OR terms, structurally the same as POS.
NAND is the negation of an AND operation, and NOR is the negation of an OR operation; since NAND alone (and separately NOR alone) can reconstruct AND, OR, and NOT, either gate type can implement any Boolean function on its own.
Map each operator to its corresponding gate — AND to an AND gate, OR to an OR gate, NOT to an inverter — after simplifying the expression first to minimize the total gate count.
Every Boolean function can be fully represented as either a sum of minterms (rows where output is 1) or a product of maxterms (rows where output is 0); these are the building blocks of SOP and POS forms respectively.
Generate its truth table: if every output row is 1, it's a tautology; if every output row is 0, it's a contradiction
Last Update: July 2026