AQA A-Level Computer Science (7517)

## Learning Outcomes

- Understand how logic gates represent binary logic inside computer hardware
- Identify the six required logic gates and recall their truth tables
- Distinguish clearly between similar gates, especially OR and XOR, AND and NAND, OR and NOR
- Write Boolean expressions from logic gate circuits using correct notation
- Draw or interpret multi-gate circuits step by step
- Complete truth tables for logic circuits using intermediate columns
- Explain how an edge-triggered D-type flip-flop stores one bit and why clock pulses matter

## AQA A-Level Computer Science (7517) Syllabus

For the AQA A-Level Computer Science (7517), you are expected to understand logic gates and logic circuits within computer systems, with a focus on the following syllabus points:

![Standard symbols and truth tables for NOT, AND, OR, XOR, NAND, and NOR logic gates.](https://static.pastpaperhero.com/images/aqa-a-level-computer-science-7517-computer-systems-logic-gates_00.png)

_NOT, AND, OR, XOR, NAND, and NOR are presented with their conventional symbols and output values for each input combination._

- Know the function of the six required logic gates: NOT, AND, OR, XOR, NAND and NOR
- Construct truth tables for individual gates and for logic gate circuits with multiple inputs
- Use and recognise the required distinctive-shape logic gate symbols
- Write Boolean expressions for given logic gate circuits using correct notation
- Draw logic gate circuits from Boolean expressions
- Explain the difference between gates that produce direct outputs and gates that invert outputs
- Understand that logic circuits are building blocks of processor and memory hardware
- Know that an edge-triggered D-type flip-flop is a one-bit memory unit controlled by the clock

## Test Your Knowledge

_Attempt these questions before reading this article. If you find some difficult or cannot remember the answers, look more closely at that area during your revision._

1. What is the difference between an OR gate and an XOR gate?
2. How do you recognise a NAND or NOR gate in a circuit diagram?
3. How many rows should a truth table have for a circuit with three inputs?
4. What is the Boolean expression for a circuit where the output is true only when both A and B are true?
5. What does an edge-triggered D-type flip-flop do?

## Introduction

Logic gates are the basic building blocks of digital hardware. At the lowest level, computers work with binary states: **1** for high voltage and **0** for low voltage. Logic gates take one or more binary inputs, apply a rule, and produce a single binary output. That sounds simple, but these small components are the basis of registers, processors, memory circuits and arithmetic units.

In the exam, logic gates are often tested in very practical ways. You may have to identify a gate from its truth table, complete a truth table for a circuit, turn a circuit into a Boolean expression, or draw a circuit from a Boolean expression. These are not separate skills. They all depend on the same idea: every circuit is just a physical way of carrying out Boolean logic.

> **Key Term: logic gate**
> A physical device that takes one or more binary inputs and produces a single binary output according to a logical rule.

### The six required logic gates and their truth tables

The specification requires you to know six gates: **NOT, AND, OR, XOR, NAND** and **NOR**. Each gate has a direct link to a Boolean expression and a truth table.

> **Key Term: truth table**
> A table showing every possible input combination and the corresponding output.
>
> **Key Term: Boolean expression**
> A symbolic way of writing a logic rule, usually using `+` for OR, `·` for AND and an overbar for NOT.

A useful starting point is this rule: with **n** inputs, a truth table has **2^n** rows. So:

- 1 input gives 2 rows
- 2 inputs gives 4 rows
- 3 inputs gives 8 rows

That matters because students often miss rows, especially in larger circuits.

#### NOT gate

The **NOT** gate is the simplest gate. It has only one input. It inverts the input:

- if A = 0, Q = 1
- if A = 1, Q = 0

Boolean form:

- Q = A̅

Truth table:

| A   | Q   |
| --- | --- |
| 0   | 1   |
| 1   | 0   |

The NOT gate is also called an **inverter**. In diagrams, the small circle, often called a bubble, shows inversion.

#### AND gate

The **AND** gate only outputs 1 when both inputs are 1.

Boolean form:

- Q = A · B

Truth table:

| A   | B   | Q   |
| --- | --- | --- |
| 0   | 0   | 0   |
| 0   | 1   | 0   |
| 1   | 0   | 0   |
| 1   | 1   | 1   |

A common way to remember this is “all required conditions must be true”. In a real system, an alarm might sound only if **sensor active AND system armed**.

#### OR gate

The **OR** gate outputs 1 if at least one input is 1.

Boolean form:

- Q = A + B

Truth table:

| A   | B   | Q   |
| --- | --- | --- |
| 0   | 0   | 0   |
| 0   | 1   | 1   |
| 1   | 0   | 1   |
| 1   | 1   | 1   |

This means OR includes the case where both are true. That is a major point of confusion.

#### XOR gate

The **XOR** gate, or exclusive OR, outputs 1 when the inputs are different.

Boolean form:

- Q = A ⊕ B

Truth table:

| A   | B   | Q   |
| --- | --- | --- |
| 0   | 0   | 0   |
| 0   | 1   | 1   |
| 1   | 0   | 1   |
| 1   | 1   | 0   |

Students often say “XOR means one or the other”. For a two-input gate, a better exam-safe phrase is: **output 1 when exactly one input is 1**.

> **Test Tip:** If you are torn between OR and XOR, check the row where both inputs are 1. OR gives 1. XOR gives 0.

#### NAND gate

The **NAND** gate is NOT-AND. It performs an AND operation, then inverts the result.

Boolean form:

- Q = (A · B)̅

Truth table:

| A   | B   | Q   |
| --- | --- | --- |
| 0   | 0   | 1   |
| 0   | 1   | 1   |
| 1   | 0   | 1   |
| 1   | 1   | 0   |

So NAND is 0 only when both inputs are 1.

#### NOR gate

The **NOR** gate is NOT-OR. It performs an OR operation, then inverts the result.

Boolean form:

- Q = (A + B)̅

Truth table:

| A   | B   | Q   |
| --- | --- | --- |
| 0   | 0   | 1   |
| 0   | 1   | 0   |
| 1   | 0   | 0   |
| 1   | 1   | 0   |

So NOR is 1 only when both inputs are 0.

> **Key Term: inversion**
> The changing of a binary value to its opposite, so 0 becomes 1 and 1 becomes 0.

The big visual clue for NAND and NOR is the output bubble. That bubble means the whole output is inverted, not just one input.

### Writing Boolean expressions and drawing circuits

A logic circuit is a combination of gates connected together to solve a problem. In exam questions, you may be asked to move between three forms:

- a written description
- a logic diagram
- a Boolean expression
  > **Key Term: logic circuit**
  > A combination of one or more logic gates connected to produce an output from given inputs.

Suppose the rule is:

- output Q is true when **A is false OR both B and C are true**

This becomes:

- Q = A̅ + (B · C)

Why are brackets needed? Because without them, the order is unclear. The brackets show that B and C go through the AND gate first, then that result goes into an OR gate with A̅.

#### Worked example: expression to circuit

Expression:

- Q = A̅ + (B · C)

Step-by-step thinking:

1. Identify each smaller part.
   - A̅ means a NOT gate on A
   - B · C means an AND gate with inputs B and C
2. Combine those outputs.
   - The result of A̅ and the result of B · C feed into an OR gate
3. The OR output is Q

So the circuit has:

- one NOT gate on A
- one AND gate joining B and C
- one OR gate producing Q

Students often go wrong by reading left to right as though the expression were arithmetic. In logic, brackets matter because they show which gates happen first.

#### Worked example: circuit to expression

Imagine a circuit where:

- A and B enter an XOR gate
- the output of that XOR enters an AND gate with C
- final output is Q

Expression:

- Q = (A ⊕ B) · C

The bracket is essential. It shows that the XOR happens first.

A very common mistake is writing:

- Q = A ⊕ B · C

That is ambiguous and may be marked wrong because it does not clearly match the circuit.

> **Test Tip:** When writing a Boolean expression from a circuit, label intermediate outputs first. For example, let X = A ⊕ B, then write Q = X · C. After that, substitute back.

#### Distinctions students commonly miss

OR vs XOR

- OR means at least one input is 1
- XOR means inputs are different

NAND vs AND

- AND outputs 1 only for 11
- NAND outputs the opposite of AND

NOR vs OR

- OR outputs 0 only for 00
- NOR outputs the opposite of OR

NOT A vs NOT(A + B)

- A̅ means only A is inverted
- (A + B)̅ means the whole OR result is inverted

That last distinction is one of the easiest ways to lose marks.

### Completing truth tables for logic circuits

A single-gate truth table is mostly recall. A multi-gate truth table tests method. The safest approach is to use intermediate columns.

Suppose:

- Q = A̅ + (B · C)

There are three inputs, so the truth table needs **2^3 = 8** rows.

Work in binary order:

| A   | B   | C   | A̅   | B · C | Q   |
| --- | --- | --- | --- | ----- | --- |
| 0   | 0   | 0   | 1   | 0     | 1   |
| 0   | 0   | 1   | 1   | 0     | 1   |
| 0   | 1   | 0   | 1   | 0     | 1   |
| 0   | 1   | 1   | 1   | 1     | 1   |
| 1   | 0   | 0   | 0   | 0     | 0   |
| 1   | 0   | 1   | 0   | 0     | 0   |
| 1   | 1   | 0   | 0   | 0     | 0   |
| 1   | 1   | 1   | 0   | 1     | 1   |

Why use intermediate columns?

Because they reduce mistakes. If you jump straight from A, B, C to Q, you have to mentally do all operations at once. Under exam pressure, that is risky. Intermediate columns show every stage in the circuit.

#### Worked example: another circuit

Expression:

- Q = (A + B)̅

Build the truth table by doing OR first, then NOT.

| A   | B   | A + B | Q   |
| --- | --- | ----- | --- |
| 0   | 0   | 0     | 1   |
| 0   | 1   | 1     | 0   |
| 1   | 0   | 1     | 0   |
| 1   | 1   | 1     | 0   |

This is why NOR is not the same as “NOT A OR B”. The inversion happens after the OR output has been produced.

> **Key Term: intermediate output**
> The result produced by a gate inside a larger circuit before the final output is reached.

#### A practical exam method

For any logic circuit question:

1. Count the inputs
2. Write the correct number of rows
3. List input combinations in a clear order
4. Add a column for each internal gate
5. Work from input side to output side
6. Write the final output last

This method is slower at first, but much more reliable.

### Why logic gates matter in computer systems

It is easy to treat logic gates as an isolated exam topic, but they matter because real computer hardware is built from them. Registers, arithmetic circuits and control systems all depend on combinations of gates.

One example is binary addition. A **half adder** adds two bits and produces:

- a **sum**
- a **carry**

For two inputs A and B:

| A   | B   | S   | C   |
| --- | --- | --- | --- |
| 0   | 0   | 0   | 0   |
| 0   | 1   | 1   | 0   |
| 1   | 0   | 1   | 0   |
| 1   | 1   | 0   | 1   |

The pattern shows:

- Sum S behaves like XOR
- Carry C behaves like AND

So a half adder can be built from an XOR gate and an AND gate. This is a strong example of how logic gates support arithmetic inside a processor.

A **full adder** extends this idea by including a carry-in from a previous stage. You do not need to treat adders as a separate topic here, but they show why logic gates are not abstract symbols. They are the basis of real operations.

Another key idea is memory. A normal combinational circuit produces outputs from current inputs only. Once the inputs change, the previous result is gone. But computers also need storage.

> **Key Term: flip-flop**
> A memory unit that can store one bit.

An **edge-triggered D-type flip-flop** stores the input bit when triggered by a clock edge, then keeps outputting that stored value until the next trigger.

> **Key Term: edge-triggered D-type flip-flop**
> A one-bit memory unit that changes state when a clock pulse edge occurs.
>
> **Key Term: clock**
> A signal that synchronises the activity of computer components.

Why is this useful? Because circuits inside a computer must work in step. If data changed continuously with every tiny fluctuation, the system would be unreliable. The clock creates fixed moments when storage elements update. On each trigger edge, the flip-flop takes in the D input and stores it. Between trigger edges, the output remains stable.

This is the difference between:

- **combinational logic**: output depends only on current inputs
- **storage elements**: output can depend on a previously stored bit

For A-level, you should know the purpose rather than the full electronics of the device. The key exam point is that a D-type flip-flop provides temporary one-bit storage controlled by the clock.

> **Test Tip:** If a question asks why a flip-flop is needed, do not just say “for memory”. Add that ordinary logic gate outputs change when inputs change, so a flip-flop is needed to hold a bit until the next clock trigger.

## Key Point Checklist

_This article has covered the following key knowledge points:_

- Logic gates are hardware components that process binary inputs to produce a binary output
- The six required gates are NOT, AND, OR, XOR, NAND and NOR
- A truth table shows every possible input combination and output
- A truth table with n inputs must have 2^n rows
- AND outputs 1 only when all inputs are 1
- OR outputs 1 when at least one input is 1, while XOR outputs 1 when the inputs differ
- NAND is the inverse of AND, and NOR is the inverse of OR
- The inversion bubble shows that a signal or output is negated
- Boolean notation commonly uses `+` for OR, `·` for AND and an overbar for NOT
- Multi-gate circuits should be converted to truth tables using intermediate columns
- Brackets are essential when writing Boolean expressions for combined gates
- An edge-triggered D-type flip-flop stores one bit and updates on a clock edge

## Key Terms and Concepts

- logic gate
- truth table
- Boolean expression
- inversion
- logic circuit
- intermediate output
- flip-flop
- edge-triggered D-type flip-flop
- clock


Computer Systems - Logic gates