OCR A-Level Computer Science: Boolean Algebra & Logic — Complete Revision Guide (H446)
OCR A-Level Computer Science: Boolean Algebra & Logic — Complete Revision Guide
Boolean algebra is the mathematics of true and false, and logic is how that mathematics becomes physical hardware. This module explains the logic gates from which every processor is built, the truth tables and algebraic laws that describe their behaviour, the techniques — including De Morgan's laws and Karnaugh maps — for simplifying logic to use fewer gates, and the combinational and sequential circuits that perform arithmetic and store state. It is the most self-contained and procedural area of OCR A-Level Computer Science (H446): the rules are few, exact and consistent, so with practice this module becomes a reliable source of full-mark answers.
In the H446 specification this material sits in module 1.4.3 (Boolean algebra) and is examined in Component 01: Computer Systems. The questions are recognisable and recurring: complete or interpret a truth table for a given gate or circuit; write the Boolean expression a logic diagram represents (or draw the diagram for an expression); simplify an expression using the Boolean laws or De Morgan's laws; use a Karnaugh map to minimise a function; and explain the operation of standard building blocks such as the half adder, full adder and D-type flip-flop. The examiner rewards exact notation and shown working — a simplification that states which law is applied at each step is far stronger than an unexplained jump to the answer.
This is Course 4 of 11 on the LearningBro OCR A-Level Computer Science learning path. The course, Boolean Algebra & Logic, opens with logic gates and truth tables, develops the Boolean laws, De Morgan's laws and the simplification techniques that culminate in Karnaugh maps, then applies them to logic circuits, adders and flip-flops, closing with circuit design. It is the hardware counterpart to the binary arithmetic of Data Representation and rests on the processor model from Processors & Hardware.
Guide Overview
The Boolean Algebra & Logic course is built as ten lessons that move from logic gates and truth tables through the Boolean laws and simplification techniques into Karnaugh maps, then apply the algebra to logic circuits, adders and sequential flip-flops, closing on circuit design.
- Logic Gates
- Truth Tables
- Boolean Algebra Laws
- De Morgan's Laws
- Simplifying Boolean Expressions
- Karnaugh Maps
- Logic Circuits
- Half Adders and Full Adders
- Flip-Flops
- Circuit Design
Logic Gates
The logic gates lesson establishes the building blocks of all digital logic. H446 expects fluency with six gates: NOT (inverts a single input), AND (output 1 only when all inputs are 1), OR (output 1 when at least one input is 1), XOR (exclusive OR, output 1 when the inputs differ), NAND (the inverse of AND) and NOR (the inverse of OR). Each has a standard symbol you must recognise and draw, and a standard Boolean notation: a dot or juxtaposition for AND, a plus for OR, a bar or prime for NOT, and a circled plus for XOR.
The conceptual point worth carrying forward is the functional completeness of NAND and NOR: any logic function whatsoever can be built from NAND gates alone, or from NOR gates alone, which is why these gates are so important in real hardware. This is the lesson to over-learn first, because every later lesson — truth tables, simplification, circuits, adders — assumes instant recall of what each gate does and how it is written.
| Gate | Notation | Output is 1 when |
|---|---|---|
| NOT A | A with bar / A' | A is 0 |
| A AND B | A.B | both A and B are 1 |
| A OR B | A + B | A or B (or both) is 1 |
| A XOR B | A (+) B | A and B differ |
| A NAND B | (A.B)' | NOT both are 1 |
| A NOR B | (A + B)' | neither is 1 |
Truth Tables
The truth tables lesson develops the systematic tool for describing exactly what a gate or circuit does for every possible combination of inputs. A truth table lists all 2^n input combinations for n inputs and the resulting output, and the disciplined habit examiners reward is to enumerate the input rows in a fixed binary-counting order (00, 01, 10, 11 for two inputs) so that no combination is missed.
The lesson teaches the two core moves: building the truth table for a multi-gate circuit by adding a column for each intermediate signal and working left to right, and reading a Boolean expression off a completed truth table by taking the rows where the output is 1. This second move — deriving the sum-of-products expression from a truth table — is the bridge to simplification, because that raw expression is usually far larger than it needs to be. Truth tables are also the standard way to prove two expressions equivalent: build both and check the output columns match, a technique reused to verify simplifications and De Morgan's laws.
Boolean Algebra Laws
The Boolean algebra laws lesson develops the algebraic identities that let you manipulate and simplify expressions without drawing a truth table each time. The laws H446 examines parallel ordinary algebra but include identities unique to Boolean logic.
| Law | Form |
|---|---|
| Identity | A.1 = A; A + 0 = A |
| Null (annulment) | A.0 = 0; A + 1 = 1 |
| Idempotent | A.A = A; A + A = A |
| Complement | A.A' = 0; A + A' = 1 |
| Double negation | (A')' = A |
| Commutative | A.B = B.A; A + B = B + A |
| Associative | A.(B.C) = (A.B).C |
| Distributive | A.(B + C) = A.B + A.C |
| Absorption | A + A.B = A; A.(A + B) = A |
The examinable skill is recognising which law applies at each step of a simplification and stating it. The absorption and complement laws in particular are where the biggest reductions come from, and the distributive law (which, unusually, works both ways in Boolean algebra) is the workhorse for factoring expressions toward a simpler form. This algebraic toolkit feeds directly into the simplifying Boolean expressions lesson.
De Morgan's Laws
The De Morgan's laws lesson develops the two transformations that handle the negation of compound expressions — the part of Boolean algebra students most often get wrong, and therefore a reliable discriminator in the exam. The laws state that the complement of an AND is the OR of the complements, and the complement of an OR is the AND of the complements:
(A.B)' = A' + B'
(A + B)' = A'.B'
The practical rule to internalise is "break the bar and change the sign": when you split a NOT across a bracket, AND becomes OR (and vice versa) and each variable is individually complemented. De Morgan's laws are essential for two recurring tasks: simplifying expressions that contain a negated bracket, and converting a design into NAND-only or NOR-only form (exploiting the functional completeness noted in the logic gates lesson). Verify any application by truth table until the transformation is second nature.
Simplifying Boolean Expressions
The simplifying Boolean expressions lesson brings the laws together into the procedural skill the exam tests most directly: taking a complicated expression — typically the raw sum-of-products read off a truth table — and reducing it to the fewest terms, which in hardware means the fewest gates. The disciplined method is to apply the laws one step at a time, writing the simplified expression and naming the law used at each step, so that the working tells a clear story and earns method marks even if a slip occurs.
The high-value moves are factoring with the distributive law, eliminating terms with the complement and absorption laws, and using De Morgan's laws to clear negated brackets. Why this matters in engineering terms is a recurring extended-answer point: a simpler expression needs fewer gates, which reduces cost, power consumption, physical space and propagation delay in the final circuit. This algebraic route to minimisation is then complemented by the visual method in the next lesson, and the two are alternative tools for the same job.
Karnaugh Maps
The Karnaugh maps lesson develops the graphical technique for minimising a Boolean function of up to four variables without algebra. A Karnaugh map is a grid with one cell per input combination, arranged so that adjacent cells differ in exactly one variable — which is why the rows and columns are labelled in Gray code (00, 01, 11, 10) rather than ordinary binary order. You plot a 1 in every cell where the function is true, then group the 1s.
The rules for grouping are precise and examinable: groups must be rectangular and contain a number of cells that is a power of two (1, 2, 4, 8); groups should be as large as possible (a larger group eliminates more variables); every 1 must be covered by at least one group; groups may overlap; and the map wraps around, so cells on opposite edges (and the four corners) are adjacent. Each group then yields one product term containing only the variables that stay constant across it, and the simplified expression is the OR of these terms. The Karnaugh map often reaches a minimal form faster and more reliably than algebra, which is exactly why H446 teaches it alongside the algebraic simplification — practise reading the minimal expression off the groups until it is routine.
Logic Circuits
The logic circuits lesson develops the two-way translation between a Boolean expression and a combinational logic diagram — a circuit whose output depends only on its current inputs. Given an expression you draw the gates that implement it, wiring inputs through AND, OR, NOT and XOR gates to the output; given a diagram you trace the signals through each gate to write the expression and, if asked, build its truth table.
The lesson stresses the standard workflow that ties the whole module together: derive an expression (often from a truth table or a worded specification), simplify it with the laws or a Karnaugh map, then draw the minimised circuit — because a simplified expression produces a smaller, cheaper, faster circuit. A combinational circuit has no memory: the same inputs always give the same output, with no dependence on past values. That limitation is precisely what motivates the sequential circuits — the flip-flops — introduced later, which can store state.
Half Adders and Full Adders
The half adders and full adders lesson applies combinational logic to binary arithmetic, connecting this module directly to the binary arithmetic of the data-representation course. A half adder adds two single bits and produces a sum and a carry: the sum is the XOR of the inputs (1 when the bits differ) and the carry is the AND of the inputs (1 only when both are 1). It is "half" an adder because it cannot accept a carry coming in from a previous column.
A full adder adds three bits — two operand bits and a carry-in — producing a sum and a carry-out, and so can be chained: connecting the carry-out of each full adder to the carry-in of the next builds a ripple-carry adder that adds multi-bit numbers, which is the arithmetic engine inside the ALU described in Processors & Hardware. The examinable requirements are to give the sum and carry expressions, complete the truth tables for both adders, and explain how full adders are cascaded to add wider numbers. This is the clearest single example in the course of abstract Boolean algebra becoming working hardware.
Flip-Flops
The flip-flops lesson introduces sequential logic — circuits whose output depends not only on current inputs but also on stored state — and so explains how computers remember a single bit. A flip-flop is a bistable circuit with two stable states (storing 0 or 1) built from cross-coupled gates with feedback, where the output is fed back into the input so the circuit holds its value until told to change.
H446 examines the D-type flip-flop, which captures the value on its data input D and transfers it to the output on the active edge of a clock pulse, holding it until the next clock edge. This clocked, edge-triggered behaviour is what makes the D-type the basic storage element for registers and memory, linking back to the registers of Processors & Hardware. The key contrast to be able to articulate is combinational versus sequential: combinational circuits (gates, adders) have no memory and respond instantly to inputs, while sequential circuits (flip-flops) store state and are synchronised by a clock signal.
Circuit Design
The circuit design lesson consolidates the whole module into the end-to-end design process the exam ultimately tests: turning a worded problem into a minimal working circuit. The workflow is to define the inputs and the desired output behaviour, build a truth table capturing the specification, read off the sum-of-products expression, minimise it using the Boolean laws or a Karnaugh map, and then draw the gate diagram for the simplified expression.
The recurring assessment pattern is a short scenario — a safety interlock, a voting system, a simple controller — that you must realise as a circuit, demonstrating each stage of the process. The marks reward a complete, ordered method: a correct truth table, a valid simplification with the technique shown, and a circuit diagram that matches the minimised expression. This is where logic gates, truth tables, the algebraic laws, De Morgan's laws and Karnaugh maps all come together in a single answer, which is exactly why circuit design closes the course.
How to Revise Boolean Algebra & Logic
This module is procedural, so the most effective revision is repeated practice of the exam moves rather than rereading definitions. Make sure you can, from memory, draw and recognise all six gate symbols and write their notation; complete a truth table in correct binary-counting order; quote the Boolean laws and De Morgan's laws; and simplify an expression while naming the law at each step. These are the recall foundations on which every question rests, and they are quick to over-learn.
Then drill the two minimisation routes — algebraic simplification and Karnaugh maps — on a steady supply of expressions, because almost every Boolean question reduces to "simplify this, then draw or interpret the circuit". Pay particular attention to the standard building blocks, since the half adder, full adder and D-type flip-flop appear repeatedly: be able to state their sum/carry or data/clock behaviour, complete their truth tables, and explain how adders cascade and how a flip-flop stores a bit. Working a handful of full design problems end to end — truth table, minimisation, diagram — is the single best preparation for the extended-answer items.
Start at the Boolean Algebra & Logic course and work through all ten lessons in order, from logic gates to circuit design. Once the gates, laws and minimisation techniques are fluent, the adders tie straight back to the binary arithmetic of the data-representation course and the flip-flops to the registers of Processors & Hardware, completing the hardware foundation of the OCR A-Level Computer Science path.