Lesson 1: Introducing the AQA A

level computer science Paper 1

Pre-release 2026 material
Ant Simulation – Exploration of the pre-release skeleton program for
Python
Learning objectives

✓Run the skeleton program

✓Investigate the subroutines Main, GetChoices,

GetCellReference, DisplayMenu in the pre-release skeleton
program for Python

✓Make modifications to the pre-release skeleton program to these

subroutines.
 Pre-release files
Download the following files from your school’s secure area according your teacher’s instruction:

Electronic Answer document

✓ 2026 Electronic Answer Document (EAD) 7517-1D Python G4002 [Link]

Preliminary material

✓ 7517-1-PM-Computer Science-A-10Jun26-PM G4003 [Link]

Skeleton Code

✓ Paper1_ALvl_2026_Python_Pub_0.[Link]

By all means make copies especially of the skeleton code for personal use

But please do not share these resources as this is a live assessment for 2025-26.
Preliminary material

Read through the preliminary material:

7517-1-PM-Computer Science-A-10Jun26-PM G4003 [Link]

Think, pair and share your initial reflections

 Complete the Parameters for the simulation

Simulation # Nests Grid size Food Cells Ants/Nest Food/Nest Peromone Pheromone
Strength Decay
1

4
 Complete the parameters for the simulation

Simulation # Nests Grid size Food Cells Ants/Nest Food/Nest Pheromone Pheromone
Strength Decay
1 1 5x5 3 5 500 1000 50

2 1 5x5 3 5 500 1000 100

3 2 10x10 3 9 500 1000 25

4 1 10x10 3 6 500 1000 25

Run

Run the code: Paper1_Alvl_2026_Python_Pub_0.[Link]

Do not look at the code at this stage. Just enjoy running the Ant
simulation!

Spend 15 minutes running the simulations

Can you identify any areas of the simulation where the game does not
work as you might expect?
Explain how the simulation works

✓Share your explanation on [Link]

✓Read the explanation of others
✓Add the explanation as a comment at the top of the skeleton code
(open the file: Paper1_Alvl_2026_Python_Pub_0.[Link])
Explain how the simulation works

This simulates the behaviour of ants. There is a two dimensional grid

that can be empty, contain ants, nests and / or food.

Worker ants randomly search the grid for food and can move to any
adjacent cell between each timestep. Once food has been found the
ant will lay down a pheromone so that other ant know where to find
the food and take in back to the nest. Other ants then move towards
the cells from which the pheromone was detected. If there is not
enough food in the nest some ants will be culled. If there is plenty of
food new ants will be born.
Investigate the code

View and open the code:

Paper1_Alvl_2026_Python_Pub_0.[Link]

Spend a few minutes perusing the code

What are your initial thoughts?

Discuss with the class
Complete the hierarchy chart

Main

GetChoice
Completed hierarchy chart

Main

GetCellRefrerence DisplayMenu GetChoice

Explain these procedure Main
Add comments to the skeleton code explaining this procedure

Main
Explain the procedure Main
Add comments to the skeleton code explaining these procedures

Main In this procedure the user needs to request which of the four
simulations that they would like to run

Once they have selected the simulation a simulation object is created.

Then the menu is displayed. The user can then has 6 options to
choose fror.
The user selects an option and the simulation action is carried out.
And the meun is displayed once again. This keeps happening until the
user chooses to quit the simulation.
Explain these procedures and functions
Add comments to the skeleton code explaining these procedures and functions

DisplayMenu

GetChoice

GetCellReference
Explain these procedures and functions
Add comments to the skeleton code explaining these procedures and functions

DisplayMenu This procedure outputs the menu display

GetChoice This function requests input from the menu for the choice
of menu

GetCellReference This function requests input from the user for the row and
column number
Modify
Extend the program so the user can specify their own simulation
parameters instead of only using the pre-set ones. Parameters are:
• number of rows
• number of columns elif SimNo == "5":
StartingNumberOfNests = int(input("Enter starting number of nests: "))
• number of nests NumberOfRows = int(input("Enter number of rows: "))
NumberOfColumns = int(input("Enter number of columns: "))
• number of food cells StartingFoodInNest = int(input("Enter starting food in each nest: "))
StartingNumberOfFoodCells = int(input("Enter number of food cells: "))
• starting ants in nest StartingAntsInNest = int(input("Enter number of ants in each nest: "))
NewPheromoneStrength = int(input("Enter new pheromone strength: "))
• pheromone strength PheromoneDecay = int(input("Enter pheromone decay rate: "))
SimulationParameters = [

• peronome decay StartingNumberOfNests, NumberOfRows, NumberOfColumns,

StartingFoodInNest, StartingNumberOfFoodCells,
StartingAntsInNest, NewPheromoneStrength, PheromoneDecay]
 Modify

When the user first stars the program it ask which simulation number
you would like to run. However it needs to display the options for the
various simulations as this would not be clear unless the user has read
the preliminary material. Create a procedure called displaySimulation()
for this and call this procedure.

def displaySimulation():
print("1) 5 x 5 grid, 1 nest, decay: 50")
print("2) 5 x 5 grid, 1 nest, decay: 100")
print("3) 10 x 10 grid, 1 nest")
print("4) 10 x 10 grid, 2 nests")
 Plenary
1. How many subroutines are there is the
skeleton code that have two parameters as
input?
2. What is the difference between a function
and procedure?
3. State the name of the identifier for the
user-defined procedures in the skeleton
code
4. State the name of the identifier for the
user-defined functions in the skeleton code
5. Explain how data are shared between the
subroutines
 Plenary
1. How many subroutines are there is the 1. 0
skeleton code that have two parameters as 2. Functions return values whereas
input? procedures do not. Procedures
2. What is the difference between a function change the state of a system eg
and procedure? change values of global variables
or complete a task like printing
3. State the name of the identifier for the
user-defined procedures in the skeleton 3. Main, DisplayMenu
code 4. GetChoice,
GetCellReference
4. State the name of the identifier for the
user-defined functions in the skeleton code 5. Data are passed into subroutines
through parameters and are
5. Explain how data are shared between the
returned from functions
subroutines
Lesson 2: Introducing the AQA A
level computer science Paper 1
Pre-release 2026 material
Ant Simulation – Exploration of the pre-release skeleton program for
Python
Learning objectives

✓Make modifications to the subroutine Main in the pre-release

skeleton program

✓Investigate the pre-release skeleton program for Python for the

classes Entity, Ant, QueenAnt and WorkerAnt
 Modify
Refer to procedure Main. When the user first starts the program it ask
which simulation number you would like to run. Any value entered
that does not have the value 1-4 will result in a runtime error, so this
needs to be corrected for
flag=True
while flag:
displaySimulation()
flag=False
[lines 11 – 18]
elif:
flag=True
Modify

In procedure Main:

Add an elif clause that if a user enters anything other that the values
1-5 and 9, then a sensible message is output that asks the user to try
again.

elif:
print(“Only values 1-5 and 9 allowed”)
 Modify
In procedure Main:
Add another simulation with the following parameters:
Grid: 7 by 7
Food: 500
Number of Nests: 2
Number of food vells: 3
Number of ants in each nest: 10
Pheromone Strength = 500
Pheromone Decay = 25

elif SimNo == “5":

SimulationParameters = [2, 7, 7, 500, 3, 10, 500, 25]
Complete the UML diagram of Ant Simulation without attribites and methods
for simplicity. Add in class names and the associations

Pheromone

Cell
QueenAnt
UML Diagram of Ant Simulation without attribites and methods
for simplicity
Ant
Simulation
Pheromone Entity

Cell
WorkerAnt QueenAnt
Nest
UML Diagram of Ant Simulation
Ant

Simulation - _NestRow: int

- _NestColumn: int
- _StartingNumberOfNests: int Entity - _Stages: int
Pheromone
- _NumberOfRows: int - _AmountOfFoodCarried: int
- _NumberOfColumns: int - _Row: int - _FoodCapacity: int
- _BelongsTo: int
- _StartingFoodInNest: int - _Column: int - _TypeOfAnt: str
- _Strength: int
- _ID: int
- _StartingNumberOfFoodCells: int - _PheromoneDecay: int
- _StartingAntsInNest: int + InSameLocation(E:Entity): bool
+ AdvanceStage(nests, ants, + IsAtOwnNest(): bool
- _NewPheromoneStrength: int + GetRow(): int
pheromones) + AdvanceStage(nests, ants, pheromones)
- _PheromoneDecay: int + GetColumn(): int
+ UpdateStrength(change) + GetDetails(): str
- _Nests: List<Nest> + GetID(): int
+ GetStrength(): int + UpdateFoodCarried(change)
- _Ants: List<Ant> + AdvanceStage(nests, ants, pheromones)
+ GetBelongsTo(): int + ChooseCellToMoveTo(...)
- _Pheromones: List<Pheromone> + GetDetails(): str + GetFoodCarried(): int
- _Grid: List<Cell>
+ GetNestRow(): int
+ SetUpANestAt(row, col) + GetNestColumn(): int
+ AddFoodToCell(row, col, qty) + GetTypeOfAnt(): str
+ GetNestInCell(C): Nest Cell
+ UpdateAntsPheromoneInCell(Ant)
+ GetNumberOfAntsInCell(C): int
- _AmountOfFood: int
+ GetNumberOfPheromonesInCell(C): int
+ GetStrongestPheromoneInCell(C): int WorkerAnt QueenAnt
+ GetDetails(): str + GetAmountOfFood(): int Nest
+ GetAreaDetails(startRow, startCol, endRow, endCol): + GetDetails(): str + constructor sets type = worker + constructor sets type = queen
str + UpdateFoodInCell(change) + GetDetails(): str
+ AddFoodToNest(food, row, col) - _FoodLevel: int + ChooseCellToMoveTo(...)
+ GetCellDetails(row, col): str - _NumberOfQueens: int
+ AdvanceStage(numStages
+ ChangeFood(change)
+ GetFoodLevel(): int
+ AdvanceStage(nests, ants, pheromones)
Explain the Class: Entity
Add comments to the skeleton code explaining the methods in this class
__init__

InSameLocation

GetRow, GetColumn,
GetID

GetDetails

AdvanceStage
Explain the Class: Entity
Add comments to the skeleton code explaining the methods in this class
__init__ Specify row and column position of cell. Set Amount of Food to 0

InSameLocation Find out how much food is in a cell

GetRow, GetColumn, Getters for row, column and ID of cell

GetID

GetDetails Returns empty string intended to be overridden by the subclass

AdvanceStage Does nothing, but is intended to be overridden by the subclass

Class: Ant
Add comments to the skeleton code explaining the methods in this class
_NextAntID = 1
__init__

GetFoodCarried
GetNestRow
GetNestColumn
GetTypeOfAnt
GetFoodCapacity
GetDetails
Class: Ant
Add comments to the skeleton code explaining the methods in this class
_NextAntID = 1 This is a class attribute. This is protected and should not be accessed
outside the class

__init__ Sets up a range of attributes

GetFoodCarried These are a range of getters for the Ant Class

GetNestRow
GetNestColumn
GetTypeOfAnt
GetFoodCapacity
GetDetails Returns ant ID, type of ant and how many stages (time steps) it has been
alive for
Class: Ant
Add comments to the skeleton code explaining the methods in this class
IsAtOwnNest

AdvanceStage
UpdateFoodCarried

_ChangeCell
_ChooseRandomNeighbour
ChooseCellToMoveTo
Class: Ant
Add comments to the skeleton code explaining the methods in this class
IsAtOwnNest Check to see if the ant is its nest or not

AdvanceStage Adds 1 to the number of stages the ant has been alive for

UpdateFoodCarried Updates (increases or decreases) the food carried by the ant

_ChangeCell Protected method: move to one of the surrounding cells

0 1 2
3 4 5
6 7 8
_ChooseRandomNeighbour Choose which random adjacent cell to move to

ChooseCellToMoveTo Designed to be overridden

Class: WorkerAnt
Add comments to the skeleton code explaining the methods in this class
__init__

GetDetails

ChooseCellToMoveTo
Class: WorkerAnt
Add comments to the skeleton code explaining the methods in this class
__init__ Set up various attributes including current grid position and grid position
of the nest

GetDetails Identifies whether a worker is carrying food and where its home nest is

ChooseCellToMoveTo If the worker ant is carrying food it will move one cell closer to the nest.
If there is no pheromone the ant will randomly move to one of the 8
adjacent cell. If there is a pheromone it will move to the cell with the
stronges pheromone
Class: QueenAnt
Add comments to the skeleton code explaining the methods in this class
__init__
Class: QueenAnt
Add comments to the skeleton code explaining the methods in this class
__init__ Speicifies the the row and column of the nest and the ant itself even
though this is the same as the queen never leaves the nest
What is the difference between QueenAnt and WorkerAnt in terms of attributes and
behaviour?

A QueenAnt has its type set to "queen" and does not carry food. A
WorkerAnt has type "worker", a food capacity of 30, can collect and
transport food, and has specific movement behaviour.
what happens in the simulation when a worker ant carrying food reaches
its nest.

The ant is detected as being at its nest. Food is added to the nest and
the ant’s carried food is set to zero.
Discuss the advantages and disadvantages of using randomisation in this
type of simulation.

• Advantage: Adds unpredictability, making ant behaviour more

realistic.
• Disadvantage: Results vary between runs, making testing and
debugging harder.
 Plenary
1. In simulate find an example of a private
method
2. In Class Ant find an example of a
protected method.
3. In cell find an example of a public
method
4. In OOP what is mean by overriding
 Plenary
1. In simulate find an example of a private 1. __GetIndex.., __GetIndicies…
method 2. _ChangeCell
2. In Class Ant find an example of a _ChooseRandomNeighbour
protected method. 3. __init__, GetAmountOFFood,
3. In cell find an example of a public GetDetails, UpdateFoodInCell
method 4. When the method in the child
4. In OOP what is mean by overriding class overrides a method of the
same name in the inherited
class
Lesson 3: Introducing the AQA A
level computer science Paper 1
Pre-release 2026 material
Ant Simulation – Exploration of the pre-release skeleton program for
Python
Learning objectives

✓Investigate the classes, Nest, Pheronome and Cell in the pre-

release skeleton program for Python

✓Make modifications to the pre-release skeleton program

Explain the Class: Cell
Add comments to the skeleton code explaining the methods in this class
__init__

GetAmountOfFood

GetDetails

UpdateFoodInCell
Explain the Class: Cell
Add comments to the skeleton code explaining the methods in this class
__init__ Specify row and column position of cell. Set Amount of Food to 0

GetAmountOfFood Find out how much food is in a cell

GetDetails Return string with amount of food present

UpdateFoodInCell Add food to cell

Explain the Class: Pheromone
Add comments to the skeleton code explaining the methods in this class
__init__

AdvanceStage

UpdateStrength

GetStrength,
GetBelongsTo
Explain the Class: Pheromone
Add comments to the skeleton code explaining the methods in this class
__init__ Specify row and column position of cell. Set Amount of Food to 0

AdvanceStage Strength of pheromone decays each time step and the decay the amount
the value decay is set to

UpdateStrength Update strength of Pheromone for that cell

GetStrength, Getters for Strength of Pheromone and which ant that pheromone belongs
GetBelongsTo to
Explain the Class: Nest
Add comments to the skeleton code explaining the methods in this class
__init__ Set up attributes needed for the class

AdvanceStage In this step if there is not enough food ants will be culled on the basis of
how much food is in the nest. If there is lots of food new ants will be born.

ChangeFood Removes or adds food to a cell. Does not allow the amount of food in the
cell to go below 0.

GetFoodLevel Getter for the amount of food in a cell

Explain the Class: Nest
Add comments to the skeleton code explaining the methods in this class
__init__

AdvanceStage

ChangeFood

GetFoodLevel
What is the purpose of the Entity class in this program?

It acts as a base class providing common attributes (row, column, ID)

and shared methods such as InSameLocation. Other classes inherit
from it to reduce code duplication.
What is meant by method overriding in the context of GetDetails()?

Subclasses replace the inherited GetDetails method with their own

version. For example, [Link]() describes food in a cell, while
[Link]() describes ant type and state.
Why is inheritance preferable to writing separate, independent classes for ants,
nests, and pheromones?

Inheritance avoids duplicating shared attributes like position. It also

allows polymorphism so that different objects can be handled in a
similar way.
How does polymorphism appear in this program?

Different entities implement AdvanceStage differently. The simulation can call

AdvanceStage on all objects without needing to know whether it’s an ant, nest,
or pheromone.
Explain the algorithm for moving a worker ant carrying food back to its
nest.

The worker ant compares its current row/column with the nest’s
row/column and steps one unit closer each stage until reaching it.
Explain how this code demonstrates the principle of encapsulation.

Attributes are prefixed with underscores to indicate private use. Access

is controlled by getter and setter methods like GetRow and
UpdateFoodCarried.
Modify

Create a new Predator class that moves randomly to any square in the
grid at each time step. This might simulate an ant eater. If the predator
is in the same cell as an ant, the ant is then eaten and is removed from
the simulation.
 Questions
1. Describe two differences between a 1. Virtual method has
implementation, can be
virtual method and an abstract method. overridden but do not have to
2. Explain how the class Cell uses be, abstract methods have no
implementation, and must be
information hiding and encapsutation overridden
3. State the type of relationship the 2. Uses protected attributes
_AmountOfFood and can only be
between the classes Simulation and accessed using Getter
Ant (GetAmountOfFood) and
changed using setter
4. State the name of an identifier for a (UpdateFoodInCell)
protected attribute in the Entity class 3. Composition association
4. _Row, _Column, _ID
Lesson 4: Introducing the AQA A
level computer science Paper 1
Pre-release 2026 material
Ant Simulation – Exploration of the pre-release skeleton program for
Python
Learning objectives

✓Investigate the class Simulate in the pre-release skeleton program

for Python

✓Make modifications to the pre-release skeleton program

Explain the class Simulate
Add comments to the skeleton code explaining this class

Method:
__init__
Explain the class Simulate
Add comments to the skeleton code explaining this class

Method: Generates grid with cells

__init__ Sets up a nest at position 2,4

Sets up additional nests as required at random positions, but first checks that there is
not already a nest at that grid position.

Adds food to a number of grid specified in the simulation. The grids are randomly
selected
Explain the Class: Simulate
Add comments to the skeleton code explaining the methods in this class
SetUPANestAt

AddFoodToCell

__GetIndex

__GetIndiciesOfNeighbours

__GetIndexOfNeighbourWith
StrongestPheromone
Explain the Class: Simulate
Add comments to the skeleton code explaining the methods in this class
SetUPANestAt Create a nest amd add a queen and a specified number of
worker ants

AddFoodToCell Add food to a cell

__GetIndex Get single value index position of the 2D grid eg

[[0,1,2],[3,4,5],[6,7,8]]

__GetIndiciesOfNeighbours Create a list of the grid (row and column) positions of the 8 cells
immediately surrounding a specified cell

__GetIndexOfNeighbourWith Identifies the surrounding cell that has the strongest

StrongestPheromone Pheromone
Explain the Class: Simulate
Add comments to the skeleton code explaining the methods in this class
GetNestInCell

UpdateAntPheromoneInCell

GetNumberofAntsInCell

GetNumberofPheromonesInCell

GetStrongestPheromoneInCell
Explain the Class: Simulate
Add comments to the skeleton code explaining the methods in this class
GetNestInCell Returns the nest that is in a given cell. If there is no nest it
returns None

UpdateAntPheromoneInCell Update pheromone in cell as this decays with each time step

GetNumberofAntsInCell Returns the number of ants in a cell

GetNumberofPheromonesInCell Returns the number of pheromones in a cemm

GetStrongestPheromoneInCell Returns the strongest pheromone in a cell

Explain the Class: Simulate
Add comments to the skeleton code explaining the methods in this class
AdvanceStage

AddFoodToNest

GetCellDetails

GetAreaDetails

GetDetails
Explain the Class: Simulate
Add comments to the skeleton code explaining the methods in this class
AdvanceStage Advance the timestep of the whole simulation, update food,
pheronomes and position of the ant and how much food
carried
AddFoodToNest Add food to the nest

GetCellDetails Gets details of a specified cell including food level,

pheromones

GetAreaDetails Gets details about cells within an are including number of

ants, number of pheromones and amount of food

GetDetails Very similar to GetAreaDetails except that it gets details for

every cell in the grid.
Why does Entity include an empty AdvanceStage method?

It defines a common interface. Subclasses override it with their own

behaviour, e.g. pheromones decay and ants move, while the base
version does nothing.
Why are leading underscores used in attribute and method names (e.g. _Row)?

By convention, they indicate private or protected variables. This warns

other programmers not to access them directly from subclasses
What data structure is used to store the simulation grid?

A one-dimensional Python list of Cell objects

Explain how the grid index is calculated using the __GetIndex method.

(Row - 1) * _NumberOfColumns + (Column - 1) maps 2D coordinates to

a single index in the 1D list.
Why is a 1D list used for _Grid instead of a 2D array structure?

It simplifies storage and indexing. A formula converts 2D coordinates

into a single index.
What does the AdvanceStage method in the Simulation class do?

It advances the simulation by one or more steps: decays pheromones,

removes expired pheromones, moves ants, updates nests, and
manages food collection/dropping.
What is the association between the cell objects and the simulation?

The simulation has a grid of cell objects. Cells are created inside the
simulation and cannot exist outside of it.
What is the association between the ants and the simulation?

The simulation has a list of ants. Ants exist independently but are
stored in the simulation.
 Questions
1. Pheromone
1. State the name of an identifier for a class that has a
constructor that takes six parameters including the 2. Automaticlly called when the object is
object parameter created from that class

2. State the purpose of a constructor method 3. Eg GetNestInCell and others

3. State the name of an identifier for a method that 4. Eg __GetIndicesOfNeighbours and others
uses definite iteration 5. Eg AdvanceStage in Nest
4. State the name of an identifier for a method that 6. Calls the constructor in the parent class to
uses nested iteration set up some attribute values
5. State the name of an identifier for a method that 7. Eg in Main: ThisSimulation =
uses nested selection Simulation(SimulationParameters)
6. What effect does the super routine in class Nest
have?
7. Give an example from the code of an object
instantiation?
Modify

Create a new SoldierAnt class. SoldierAnts randomly patrol around the

grid moving to one of the eight random adjacent cells. If a workerAnt
from another nest enters a cell at the same time as a SoldierAnt then
the workerAnt is culled. The SoldierAnt ignores workerAnts from its
own nest
Lesson 5: Introducing the AQA A
level computer science Paper 1
Pre-release 2026 material
Ant Simulation – Exploration of the pre-release skeleton program for
Python
Learning objectives

✓Make modifications to the pre-release skeleton program

Modify

As the simulation currently stands all the ants will eventually die if the
simulation is left to run for long enough either because the food
sources will run out as these are specified at the start of the simulation
or because the food source may not be found

Modify the code so that 100 units of food are added to a random cell
every 10 time steps (stages), even if that cell already contains food.
Modify

Allow the user to save the current state of a simulation to a file

Allow the user to reload the simulation from a file

Modify

As the simulation stands ants can only die if food sources are too low.
Modify the code so that ants can also die of natural courses. This too
can be random so each stage there is a 1 in 20 chance (5%) that an ant
will die of natural causes.
 Questions
1. In subroutine Main state the name of a built-in function with a 1. input, print
single string parameter
2. __GetIndex,
2. State the name of an identifier for a private method in the
Simulation class
__GetIndicesOfNeighbours,
__GetIndexOfNeighbourWithStro
3. State the name of an identifier for a class that inherits from ngestPheromone
another class
3. Nest, Ant, Pheromone, Cell all
4. State the name of an identifier for protectedmethod in the Ant
class that has four parameters (including the object parameter). inherit from Entity; workerAnt
and QueenAnt inherit from Ant
5. State the name of an identifier that is a Boolean variable
4. _ChangeCell

5. Allowed, Chosen