AQA A Level Computer Science 7517
Complete reference for AQA A Level Computer Science students — programming, data structures, algorithm complexity, theory of computation, data representation, architecture, networking, databases, and Boolean algebra.
Our formula sheets are free to download — save this one as PDF for offline revision.
Aligned with the latest 2026 syllabus and board specifications. This sheet is prepared to match your exam board’s official specifications for the 2026 exam series.
AQA A Level Computer Science (7517) is heavy on theory, algorithm complexity, and quantitative data representation. This formula sheet pulls together every reusable formula, complexity result, and architectural framework you need across both Paper 1 and Paper 2.
Algorithm complexity (Big-O) for searching, sorting, and graph traversal
Data representation formulas — bitmap size, sound sampling, normalisation
Computer architecture, networking, and database normalisation
Boolean algebra, logic gates, and Karnaugh map simplification
Core programming paradigms and the data structures examiners expect you to recognise.
Primitive types
int, real (float), Boolean, char, string Constructs
Sequence, selection (if/else, switch/case), iteration (for, while, repeat-until), recursion Parameter passing
By value (copy passed) vs by reference (address passed — changes affect the original) Class (template) → object (instance) → encapsulation (private fields, public methods) → inheritance (subclass extends superclass) → polymorphism (same method, different behaviour) → abstraction Linear
Arrays (fixed size, contiguous), lists (dynamic), tuples (immutable), strings Queues
Linear (FIFO), circular (wrap-around with pointers), priority (highest priority dequeued first) Stacks
LIFO — push, pop, peek; used for function calls, expression evaluation, undo Hash tables
Key → hash function → bucket; collision resolution by chaining or open addressing Graphs
Vertices and edges; directed/undirected, weighted/unweighted; adjacency matrix vs adjacency list Trees
Binary search tree (left < root < right); traversals: pre-order (NLR), in-order (LNR — sorted output for BST), post-order (LRN) Other
Dictionaries (key-value), vectors Memorise these complexities — they are tested directly and underpin theory of computation.
Linear search
O(n) — works on unsorted data; check each element in turn Binary search
O(log n) — requires sorted data; halve the search space each step Bubble sort
O(n²) — repeatedly compare adjacent pairs and swap; simple, inefficient Merge sort
O(n log n) — divide and conquer; recursively split, sort halves, merge Insertion sort (extension)
O(n²) worst-case, O(n) best-case (already sorted) Dijkstra's shortest path
Single-source shortest path on weighted graphs with non-negative weights — uses priority queue A* search
Heuristic-guided shortest path: f(n) = g(n) + h(n) where g = cost so far, h = heuristic estimate BFS (Breadth-First)
Uses a queue — explores level by level — finds shortest path on unweighted graphs DFS (Depth-First)
Uses a stack (or recursion) — explores deeply before backtracking Tree traversals
Pre-order, in-order, post-order — recursive on left/right subtrees Reverse Polish Notation (RPN)
Postfix evaluation using a stack: push operands; on operator, pop two, apply, push result Big-O classes, halting problem, Turing machines, regex, FSMs.
O(1) constant → O(log n) logarithmic → O(n) linear → O(n log n) linearithmic → O(n²) quadratic → O(2ⁿ) exponential Always state best, average, and worst-case complexities where they differ.
Halting problem — proven undecidable: no algorithm can determine for all inputs whether an arbitrary program halts Turing machine = infinite tape + read/write head + state register + finite transition rules → theoretical model of computation Regex operators
* (zero or more), + (one or more), ? (zero or one), | (alternation), [...] (character class) FSM
States + transitions + start state + accepting state(s); FSMs recognise regular languages All the quantitative formulas examiners expect you to apply confidently.
Binary, denary, hex (base 16) — convert via repeated division/multiplication or grouping nibbles Two's complement (signed)
Invert all bits then add 1 → MSB is sign bit; range for n bits = −2^(n−1) to 2^(n−1) − 1 Unsigned range
0 to 2ⁿ − 1 Floating point
value = mantissa × 2^exponent — both stored in two's complement Normalisation
Adjust mantissa so first two bits differ (e.g. 0.1... or 1.0...) → maximises precision ASCII — 7-bit (128 chars); extended ASCII — 8-bit (256). Unicode — UTF-8 (1–4 bytes, ASCII-compatible), UTF-16, UTF-32 Bitmap file size (bits)
width × height × bit depth → divide by 8 for bytes Number of colours
2^(bit depth) Vector graphics
Stored as drawing instructions (lines, curves, shapes) with attributes — scale without quality loss Nyquist's theorem
Sampling rate must be ≥ 2 × highest frequency to avoid aliasing File size (bits)
sampling rate (Hz) × bit depth × duration (s) × channels Compression
Run-Length Encoding (RLE), dictionary-based (e.g. LZW); lossy (JPEG, MP3) vs lossless (PNG, FLAC, ZIP) Symmetric encryption
Same key encrypts and decrypts (e.g. Caesar cipher, Vernam one-time pad — perfect secrecy if key truly random and used once) Asymmetric encryption
Public key + private key (e.g. RSA — based on difficulty of factoring large primes) Hardware/software, von Neumann, fetch-execute, and CPU performance factors.
Hardware (physical components) vs software (programs); system software (OS, utilities, library, translators) vs application software (general-purpose, special-purpose) OS roles
Resource management, memory management, file management, process scheduling, providing user/HW interface Von Neumann
Single shared bus and memory for instructions and data — simpler, cheaper, but bottleneck Harvard
Separate memory and buses for instructions vs data — faster, used in DSPs and embedded systems FETCH: PC → MAR → memory → MDR; instruction → CIR; PC incremented. DECODE: control unit decodes opcode in CIR. EXECUTE: ALU/registers carry out instruction Clock speed (Hz), number of cores, cache size and levels (L1/L2/L3), word length, bus width, pipelining RISC
Few simple instructions, fixed length, register–register, hardwired control — efficient pipelining (e.g. ARM) CISC
Many complex instructions, variable length, microcode — fewer instructions per program (e.g. x86) GPUs / multicore
SIMD parallelism in GPUs; multicore enables true parallel processing across threads Networking layers, addressing, and database normalisation/SQL.
Serial (one bit at a time, long-distance) vs parallel (multiple bits, short-distance, skew issues); bandwidth (bits/sec), baud rate (signal changes/sec), latency (delay) LAN vs WAN
LAN — single site, owned; WAN — geographically dispersed, often leased lines Switching
Packet switching (data split into packets, routed independently — used by the Internet) vs circuit switching (dedicated path for duration of call) Topologies
Bus, star, ring, mesh — trade off cost, redundancy, scalability Application (HTTP, FTP, SMTP) → Transport (TCP/UDP — segmentation, ports) → Internet/Network (IP — routing, addressing) → Link (Ethernet, MAC — physical transmission) Addresses
IPv4 (32-bit, dotted decimal), IPv6 (128-bit, hex), MAC (48-bit, hardware), DNS (resolves domain → IP), firewalls and packet filtering Relational model
Tables (relations) with rows (tuples) and columns (attributes); primary key (unique identifier), foreign key (refers to PK in another table) Normalisation
1NF — atomic values, no repeating groups; 2NF — 1NF + no partial dependencies on composite key; 3NF — 2NF + no transitive dependencies Core SQL
SELECT cols FROM table WHERE condition JOIN ... ON ... GROUP BY col HAVING ... ORDER BY col ASC|DESC Transactions — ACID
Atomicity, Consistency, Isolation, Durability CAP theorem
Distributed systems can guarantee at most two of: Consistency, Availability, Partition tolerance Big Data
NoSQL (document, key-value, graph) and parallel/distributed processing (e.g. MapReduce) for volume, velocity, and variety Functional programming
Functions as first-class citizens; higher-order functions map / filter / reduce; immutability; recursion replaces iteration; pure functions (no side effects) Gate identities, De Morgan's laws, and Karnaugh map simplification.
AND (·), OR (+), NOT (¬ or overbar), XOR (⊕), NAND (¬AND), NOR (¬OR) — universal gates: NAND and NOR alone can implement any Boolean function Identity
A · 1 = A; A + 0 = A Null
A · 0 = 0; A + 1 = 1 Idempotent
A · A = A; A + A = A Complement
A · ¬A = 0; A + ¬A = 1 Absorption
A · (A + B) = A; A + (A · B) = A ¬(A · B) = ¬A + ¬B | ¬(A + B) = ¬A · ¬B Use De Morgan's to convert between AND/OR forms — invaluable for simplification and NAND/NOR-only implementations.
Plot truth-table 1s on a Gray-coded grid → group adjacent 1s in powers of 2 (1, 2, 4, 8) → each group becomes a product term → sum the terms for minimal SOP expression Larger groups = simpler terms. Wrap around edges and corners are valid adjacencies.
Boost your Cambridge exam confidence with these proven study strategies from our tutoring experts.
Learn the complexities of every searching, sorting, and graph algorithm by heart. Big-O questions are quick marks — never lose them.
Practise bitmap size, sound file size, two's complement, and floating-point normalisation until they are automatic. These are guaranteed marks every year.
Walk through FETCH → DECODE → EXECUTE for a sample instruction, naming every register (PC, MAR, MDR, CIR) — this prepares you for high-mark architecture questions.
Boolean simplification using K-maps is faster and less error-prone than algebraic manipulation under exam pressure. Practise 3- and 4-variable maps weekly.
Quick answers about this free PDF and how to use it for exam revision and active recall.
Yes. This Tutopiya formula sheet is free to use and you can download it as a PDF from this page for offline revision. There is no payment or account required for the PDF download.
This page groups key Computer Science formulas in one place for revision. Master AQA A Level Computer Science (7517) with this 2026 formula sheet. Covers programming, data structures, algorithms with Big-O complexity, theory of computation, data representation, networking, databases, and Bo… Always cross-check with your official syllabus and past papers for your exam session.
No. In the exam you must follow only what your exam board allows in the hall—usually the official formula booklet or data sheet where provided. This page is a revision and teaching aid, not a replacement for board-issued materials.
It is written for students preparing for assessments at Post-Secondary in Computer Science, including classroom revision, homework support, and independent study. Teachers and tutors can also share it as a quick reference.
Work through past paper questions, quote the correct formula before substituting values, and check units and notation every time. Pair this sheet with timed practice and mark schemes so you see how examiners expect working to be set out.
Explore Tutopiya’s study tools, past paper finder, and revision checklists linked from our tools hub, or book a trial lesson with a subject specialist for personalised support alongside this formula reference.
Work through algorithm complexity, data representation, and architecture problems with an experienced AQA A Level Computer Science tutor. We focus on exam technique, problem-solving, and high-mark theory questions.
Pair this formula sheet with past papers, revision checklists, and planners — all free on our study tools hub.
This formula sheet aligns with the AQA A Level Computer Science (7517) specification and 2026 assessment.
Always show working for Big-O justifications, two's complement, and Boolean simplifications — examiners reward method as well as the final answer.