Logic Gates for Beginners: AND, OR, NOT and a Binary Adder

Every calculation a computer does, from adding two numbers to running a game, comes down to billions of tiny switches called transistors, wired together into logic gates. A logic gate takes one or two inputs that are either 1 (on, true) or 0 (off, false) and produces a single output according to a simple rule. Put enough of them together and you get arithmetic, memory and, eventually, a whole processor.

This guide covers the basic gates and their truth tables, then builds something real from them: a circuit that adds binary numbers. Every gate and circuit is written in Python and tested, including an adder checked against all 256 possible pairs of 4-bit numbers. Logic gates are part of GCSE, IGCSE and Class 11 computer science, and this is a good way to understand them rather than just memorise the tables.

The basic gates

• AND: the output is 1 only if both inputs are 1. "I will go out if it is sunny AND I have finished my homework."
• OR: the output is 1 if at least one input is 1. "The alarm sounds if the door OR the window opens."
• NOT: one input, and the output is the opposite. 1 becomes 0 and 0 becomes 1.
• XOR (exclusive OR): the output is 1 if the inputs are different. "Either one, but not both."

A truth table lists every possible combination of inputs and the output for each. With two inputs there are only four combinations, so a whole gate fits in four rows. Python's &, | and ^ operators work on 0s and 1s exactly like AND, OR and XOR:

from itertools import product

def AND(a, b): return a & b
def OR(a, b):  return a | b
def NOT(a):    return 1 - a
def XOR(a, b): return a ^ b

print(" A B | AND OR XOR")
for a, b in product([0, 1], repeat=2):
    print(f" {a} {b} |  {AND(a, b)}   {OR(a, b)}   {XOR(a, b)}")

A B | AND OR XOR
 0 0 |  0   0   0
 0 1 |  0   1   1
 1 0 |  0   1   1
 1 1 |  1   1   0

The same logic appears in every programming language as and, or and not in if statements. Boolean logic is named after George Boole, who described this algebra of true and false in the mid-1800s. In 1937, Claude Shannon showed that electrical switching circuits could carry it out, which is the idea every digital computer is built on.

Adding two bits: the half adder

Here is where gates become arithmetic. In binary, adding two single bits gives: 0 + 0 = 0, 0 + 1 = 1, 1 + 0 = 1, and 1 + 1 = 10 (that is 2, written as a 0 with a 1 carried). Look at the two output columns: the sum bit is 1 exactly when the inputs differ, which is XOR, and the carry is 1 only when both are 1, which is AND.

That pair of gates is called a half adder. It is "half" because it cannot accept a carry coming in from the column to its right. A full adder fixes that by using two half adders and an OR gate, so it adds three bits: A, B and the incoming carry.

Adding whole numbers: the ripple-carry adder

Line up four full adders, one per column, and pass each carry to the next column on the left, exactly like column addition on paper. The code below builds this adder from nothing but AND, OR and XOR, then checks it against Python's own addition for every pair of numbers from 0 to 15:

def AND(a, b): return a & b
def OR(a, b):  return a | b
def XOR(a, b): return a ^ b

def half_adder(a, b):
    return XOR(a, b), AND(a, b)                  # (sum bit, carry)

def full_adder(a, b, carry_in):
    s1, c1 = half_adder(a, b)
    s2, c2 = half_adder(s1, carry_in)
    return s2, OR(c1, c2)

def add_4bit(x, y):
    """Add two 4-bit numbers using only the gates above."""
    carry, result = 0, 0
    for i in range(4):                           # rightmost bit first
        bit, carry = full_adder((x >> i) & 1, (y >> i) & 1, carry)
        result |= bit << i
    return result, carry

total, overflow = add_4bit(6, 7)
print(f"0110 + 0111 = {total:04b} (that is 6 + 7 = {total}), carry out {overflow}")

total, overflow = add_4bit(9, 8)
print(f"1001 + 1000 = {total:04b} with carry out {overflow}: 17 does not fit in 4 bits")

wrong = [(x, y) for x in range(16) for y in range(16)
         if add_4bit(x, y)[0] + 16 * add_4bit(x, y)[1] != x + y]
print(f"checked all 256 pairs of 4-bit numbers: {len(wrong)} wrong")

0110 + 0111 = 1101 (that is 6 + 7 = 13), carry out 0
1001 + 1000 = 0001 with carry out 1: 17 does not fit in 4 bits
checked all 256 pairs of 4-bit numbers: 0 wrong

6 + 7 comes out as 1101, which is 13, and all 256 pairs are correct. The second example shows overflow: 9 + 8 = 17 needs 5 bits, so a 4-bit adder keeps only 0001 and sets the carry-out flag. Real processors add 64-bit numbers with faster designs than this, but the building blocks are the same gates.

NAND: one gate to build them all

A NAND gate (NOT AND) outputs 0 only when both inputs are 1. Remarkably, every other gate can be built from NAND gates alone, which makes it a universal gate. That matters in practice, because chip makers can build whole circuits from one very efficient design.

from itertools import product

def NAND(a, b):
    return 1 - (a & b)

# Every other gate, built from NAND alone
def NOT(a):    return NAND(a, a)
def AND(a, b): return NOT(NAND(a, b))
def OR(a, b):  return NAND(NOT(a), NOT(b))
def XOR(a, b):
    n = NAND(a, b)
    return NAND(NAND(a, n), NAND(b, n))

ok = all(AND(a, b) == (a & b) and OR(a, b) == (a | b) and XOR(a, b) == (a ^ b)
         for a, b in product([0, 1], repeat=2)) and NOT(0) == 1 and NOT(1) == 0
print("NOT, AND, OR and XOR built only from NAND:", "all correct" if ok else "WRONG")

NOT, AND, OR and XOR built only from NAND: all correct

NOT is a NAND with both inputs joined together. AND is NAND followed by NOT. OR uses NOT on each input, then NAND. XOR takes four NANDs. The code tests every one against its truth table. NOR (NOT OR) is also universal.

Exam tips

1. Learn the rules, not just the tables. "AND needs both, OR needs at least one, XOR needs exactly one" lets you rebuild any table in seconds.
2. Work through circuits one gate at a time, writing the output of each gate before moving on. Add a column to the truth table for each intermediate result.
3. Count the rows: 2 inputs means 4 rows, 3 inputs means 8, n inputs means 2ⁿ.
4. Know the symbols used by your exam board, and the notation for expressions such as A AND (NOT B).

A computer is billions of switches following three simple rules. Everything else is how they are wired together.

How we teach it

Logic gates reward a principle on our how we teach page: tracing line by line until every step can be predicted. Working through a circuit gate by gate, writing each output before moving on, is exactly that. Learning by building helps too: a working adder made from gates makes binary arithmetic concrete. Our GCSE computer science tutoring runs one to one or in small groups of 5 to 10.

Frequently asked questions