Additional Mathematics Step Granularity | Clear Working Without Wasting Time

A mathematical step can be correct and still be too large.

A student writes three transformations in one line, reaches the right expression, and later cannot see where a sign error entered. Another student writes every tiny arithmetic movement on a separate line, uses half a page for routine algebra and runs short of time. One learner skips from the original equation to a simplified result because the intermediate work feels obvious. Another writes so much working that the real state of the problem disappears inside visual noise.

These are not simply differences in neatness. They are differences in step granularity: how much mathematical change is packed into each visible transition.

Step Granularity asks:

How large should this next step be so that I stay fast without hiding more mathematical risk than I can safely inspect?

This guide is global and board-agnostic. It applies to Additional Mathematics, Additional Maths, A-Math and comparable advanced secondary mathematics courses worldwide. Where a qualification awards process or method marks, visible working can matter, but the official mark scheme and examination instructions remain authoritative. The same applies to calculator recording, proof presentation and required working conventions.

The public search language around this problem is familiar: show your working, step-by-step algebra, multi-step equations, clear mathematical working, check your work, exam accuracy, skipped steps, structured solutions. Step Granularity gives those familiar phrases a more precise mechanism: not simply “write more”, but choose the right size of written transformation for the current risk.

This article continues the eduKateSG examination-performance system after Checkpoint Architecture, Working Legibility, Notation Integrity, Proof Obligations and Case Coverage. The canonical job here is distinct: controlling how much mathematical work is compressed into each visible transition.

The 50-second route

Make risky steps smaller. Signs, fractions, substitutions, branch changes, parameter conditions and function-level changes deserve more visible detail.
Let routine steps stay compact. Reliable low-risk algebra does not need ceremonial expansion.
Avoid hidden compound steps. If one line performs several independent changes, error localisation becomes expensive.
Keep one dominant idea per transition. A line can contain several mechanical simplifications if they belong to one obvious operation.
Preserve checkable states. Important intermediate forms should exist somewhere on the page when later verification may need them.
Reduce rollback distance. If an error is found, you should not need to reconstruct six invisible transformations.
Increase granularity under uncertainty. When you are less sure, expose more of the route.
Decrease granularity under mastery. When a transformation is stable and low-risk, compress it.
Do not confuse short working with efficient working. A missing step can create more correction time than it saves.
Do not confuse long working with rigorous working. Excess detail can bury the state and cost time.

Alicia compresses three changes into one line

Alicia is fast. She can often see several algebraic moves mentally, so her written work jumps from one form to another.

In a familiar equation, that can be efficient. In a long A-Math solution containing negatives, fractions and a parameter, the same habit becomes dangerous.

She distributes a negative sign, combines fractions and moves a term across the equality sign in one transition. The result is wrong. The page does not reveal which operation caused the error.

Alicia’s repair is not “write everything”. It is risk-sensitive decompression: break a compound step apart only where several independent failure modes are stacked together.

Tricia writes every micro-step and loses the question

Tricia reacts in the opposite direction. She writes every cancellation, every small arithmetic simplification, every move of a factor and every obvious substitution on a new line.

Her working is visible, but the main mathematical state becomes harder to see. A six-line argument becomes twenty lines. Re-entry takes longer because important transitions are buried inside low-value detail.

Tricia’s repair is semantic compression: preserve lines where the mathematical meaning changes, while allowing routine mechanical cleanup to travel with the main operation.

Kai Kai skips the line that would have caught the sign error

Kai Kai works well under speed until late in the paper. Then he begins skipping intermediate lines.

He expands a bracket mentally and writes the collected expression immediately. One minus sign is lost. Because the expanded-but-uncollected state never appeared, the error has no local checkpoint.

His repair is to identify high-error transitions that must remain visible even under time pressure.

Step Granularity is not Working Legibility

Working Legibility asks whether the page makes the current state, route, branches and corrections easy to inspect. Step Granularity asks how much mathematical transformation should occur between two visible states.

A page can be visually neat but use jumps that are too large. It can also be visually organised but contain far too many trivial intermediate states.

Step Granularity is not Checkpoint Architecture

Checkpoint Architecture decides where independent verification should occur. Step Granularity decides how much work is exposed between those checkpoints.

A checkpoint can be well placed and still be expensive if the preceding step hides too many transformations.

Step Granularity is not Mathematical Transformation

BukitTimahTutor’s specialist mathematics owners cover transformations, equivalence and reversible steps. Step Granularity does not claim those mathematical theories.

Its performance question is narrower: how many legitimate transformations should be compressed into one written transition during examination work?

Step Granularity is not Essential Working

Essential Working concerns what must be shown or communicated sufficiently for the mathematical solution and assessment context. Step Granularity concerns the size of the transitions chosen while producing that working.

A student can include all essential working but still choose poor step sizes.

What is a mathematical step?

For this article, a step is one visible transition from one written mathematical state to the next.

The transition may contain:

one algebraic operation;
one substitution;
one factorisation;
one differentiation rule;
one branch decision;
one transformation plus obvious simplification;
several mechanical sub-operations that together form one stable chunk.

The useful unit is not “one symbol moved”. The useful unit is one inspectable mathematical chunk.

Atomic steps

An atomic step exposes a single meaningful transformation.

Examples include:

expand one bracket structure;
substitute one known value;
differentiate one expression;
apply one branch definition;
factor out one common factor;
move from exact form to a declared approximation.

Atomic steps maximise visibility but can be too slow if used everywhere.

Compound steps

A compound step compresses several transformations into one visible transition.

Compound steps are efficient when:

the transformations are strongly practised;
their error rate is low;
their order is obvious;
they do not create or retire constraints;
they do not change branch or function level;
the result can be checked cheaply;
rollback would remain short.

Compound steps become dangerous when several independent risks are bundled together.

Hidden multi-operation leaps

The most dangerous large step is not merely long. It performs several different kinds of work at once.

For example, one line might:

expand;
change signs;
combine fractions;
substitute a parameter;
collect like terms;
round a value.

If the output is wrong, six independent causes are possible. That is poor granularity.

The one-dominant-change rule

A strong default is:

One dominant mathematical change per visible transition, with low-risk mechanical simplification allowed around it.

This is not a formal rule of mathematics. It is an examination-performance heuristic.

For example, substituting x=3 and simplifying 2(3)+5 to 11 can reasonably remain one line. Substituting x=3, changing a branch, expanding two brackets, cancelling a denominator and rounding to three significant figures should probably not.

Rollback distance

Rollback distance is the amount of hidden reconstruction required when a later check finds something wrong.

If a line compresses five transformations, the student may need to mentally replay all five to locate the error.

If the same work is split into two or three meaningful transitions, the error search becomes local.

Good Step Granularity keeps rollback distance proportional to the risk of the transformation.

Error localisation

Visible intermediate states create diagnostic boundaries.

If State A is correct and State B is wrong, the error is inside that transition.

The larger the transition, the larger the search space.

This is why showing working can improve more than communication. Properly sized working reduces the cost of self-repair.

Inspection cost

Small steps lower local inspection cost but increase page length. Large steps shorten the page but increase inference cost.

The optimal step is not the shortest or longest. It is the one that minimises total cost:

writing time + reading time + checking time + repair time + re-entry time.

State exposure

Some intermediate states deserve to be visible because later reasoning depends on them.

factored form revealing roots;
expanded form revealing coefficients;
derivative before solving f′(x)=0;
substitution definition before transforming variables;
candidate set before filtering;
branch condition before local solving;
exact state before decimal presentation.

Skipping these states can remove useful checkpoints and weaken later provenance.

Risk-adaptive granularity

Step size should change with risk.

Transition	Typical risk	Granularity tendency
routine substitution	low	larger
simple collecting like terms	low	larger
negative through brackets	medium-high	smaller
fractional algebra	high	smaller
parameter threshold	high	smaller
branch change	high	smaller
function to derivative	medium-high	smaller
exact to approximate	medium	smaller
well-practised arithmetic cleanup	low	larger

Granularity should change with uncertainty

A familiar transformation can be compressed. An unfamiliar transformation should be exposed.

If you are thinking:

“I think these three changes are safe…”

that uncertainty is itself a reason to reduce step size.

Granularity should change with fatigue

A step size that is safe at minute 20 may be too large at minute 100.

Fatigue increases:

sign loss;
copying errors;
state confusion;
premature rounding;
branch leakage;
prime/index loss.

Late in the paper, strong students may deliberately make a few high-risk transitions more explicit.

Granularity should change with topic

Different topics carry different natural step sizes.

Algebraic manipulation may tolerate compact low-risk simplification. Trigonometric solution sets may need visible quadrant or interval states. Calculus may need the derivative shown before stationary-point solving. Parameter questions may need thresholds isolated before generic algebra proceeds.

The aim is not topic-specific formatting. The aim is to expose the states where meaning or risk changes.

Multi-step equations and the granularity ladder

Public maths-learning resources often teach multi-step equations using explicit intermediate states because learners need to see the relationship preserved across operations. Advanced students later compress those routines.

This suggests a granularity ladder:

Learning granularity: expose nearly every meaningful operation.
Stable granularity: compress reliable routine chunks.
Performance granularity: use the smallest amount of visible work that still protects correctness, inspection and assessment needs.

The goal is not to stay forever at beginner-level step size. The goal is to earn compression through reliability.

Compression must be earned

A student should compress a repeated transformation only after evidence shows that:

the error rate is low;
signs survive;
notation survives;
constraints are preserved;
the student can reconstruct the hidden substeps if challenged;
timed work remains stable;
late-paper work remains stable.

Compression without reliability is merely omission.

Decompression is not failure

Strong students sometimes believe that writing an extra intermediate line means they are becoming slower or weaker.

That is incorrect. Strategic decompression is a control response.

If the expression becomes unfamiliar, the signs become dense, the parameter enters a denominator or a branch condition changes, making the next step smaller can increase overall speed by preventing repair later.

The granularity tax

Every extra line has a cost:

writing time;
visual space;
re-reading time;
attention switching;
potential clutter.

Every omitted line also has a cost:

hidden error risk;
longer rollback distance;
harder checking;
reduced method visibility;
harder re-entry;
weaker provenance.

Step Granularity balances these two taxes.

Step size and method marks

In qualifications where process or method marks are awarded, visible working can allow an examiner to identify correct mathematical progress even when the final answer is wrong. The exact marking rules differ by board and question, so students should follow the official guidance for their examination.

The performance lesson is broader: a result with no visible route gives both the examiner and the student less evidence about what was done correctly.

Step size and checking

“Check your work” is only cheap when the work has useful inspection points.

If a student compresses a ten-second mental derivation into one line, later checking may require repeating the whole ten seconds.

If the same derivation exposes one critical intermediate state, checking can begin there instead.

Step size and skipped-step errors

A skipped step is not automatically an error. Advanced mathematical writing routinely compresses obvious operations.

The problem is a skipped-risk step: a hidden transition whose failure probability or downstream cost is too high to justify invisibility.

Examples include:

sign-sensitive expansion;
cancellation requiring a nonzero condition;
squaring that may introduce candidates;
substitution with a return map;
branch-specific simplification;
rounding that changes the authoritative value;
function-to-derivative transition.

Step size and mathematical communication

Clear working is not the same as maximal working.

A reader should be able to understand the route without being forced to reconstruct important transformations mentally. At the same time, the reader should not be buried under mechanical detail that obscures the main structure.

Good granularity creates an efficient shared interface between solver, checker and examiner.

Step size and Notation Integrity

Large compound steps increase the risk that signs, primes, subscripts and variable roles change invisibly.

Notation Integrity improves when notation-sensitive transitions are exposed as their own states.

Step size and State Versioning

Each written line can act as a state snapshot. If too many transformations occur between snapshots, it becomes harder to know when the authoritative state changed incorrectly.

State Versioning therefore benefits from granularity that exposes meaningful state changes without recording every trivial micro-state.

Step size and Proof Obligations

Large steps can hide the moment when a proof obligation should have been discharged.

For example, a student may jump from a candidate stationary point directly to “maximum” without exposing the classification step. Proof Obligations tells us classification is owed; Step Granularity makes space for that obligation to appear visibly.

Step size and Case Coverage

Branches often deserve smaller step size at entry and exit.

At branch entry, the condition must be attached. At branch exit, local candidates must be validated and reconciled. Compressing those transitions increases the risk of branch leakage and missing cases.

Step size and Representation Fidelity

Representation changes are high-value transitions. Moving from words to equations, graph to algebra, geometry to coordinates or transformed variables back to original variables often deserves a visible intermediate bridge.

Representation Fidelity owns meaning preservation. Step Granularity asks how much of that translation should be exposed at once.

The granularity ladder

Level	Description	Best use
G1 Micro	one tiny operation per line	new skill, severe error repair
G2 Atomic	one meaningful transformation	high-risk or uncertain work
G3 Chunked	one dominant transformation plus safe cleanup	default exam working
G4 Compressed	several reliable transformations	low-risk mastered routines
G5 Opaque	large jump requiring reconstruction	usually avoid in high-stakes working

The labels are a training model, not a formal mathematical classification.

The granularity decision

Before making a large jump, ask:

How many independent operations am I combining?
What is the probability of a sign or notation error?
Would a condition be created or lost?
Would the branch or representation change?
Could I cheaply verify the result?
If wrong, how far would I need to roll back?

If several answers indicate risk, make the step smaller.

The compression gate

A repeated transformation may be compressed when all of these are mostly true:

high familiarity;
low historical error rate;
no new condition;
no branch change;
no representation switch;
no precision change;
cheap verification;
short rollback distance.

The decompression trigger

Make the next transition smaller when any of these appear:

multiple negatives;
nested fractions;
unfamiliar factorisation;
parameter in denominator;
candidate generation;
piecewise definition;
endpoint or exceptional value;
function/derivative switch;
exact-to-decimal conversion;
late-paper fatigue;
recent error in the same routine.

Step Granularity and examination speed

The fastest solution is not always the one with the fewest lines.

Total examination time includes:

writing;
thinking;
checking;
repairing;
re-entering after skips;
reconstructing hidden steps.

A slightly longer first-pass solution can be faster overall if it prevents expensive rework.

Step Granularity and examination accuracy

Exam accuracy improves when high-risk transformations become locally inspectable.

This does not mean reducing every transformation to beginner-level detail. It means exposing the transitions that historically create avoidable errors for that student.

The step-granularity dashboard

Measure	Question	Desired direction
Opaque-jump rate	How often does a line hide several independent operations?	Down
Over-expansion rate	How often is routine work written at unnecessary micro-level?	Down
Rollback distance	How much work must be reconstructed after an error?	Down
Error localisation speed	How quickly can the faulty transition be found?	Up
High-risk visibility	Are sign/branch/constraint transitions exposed?	Up
Compression reliability	Do compressed routines remain accurate?	Up
Late-paper granularity stability	Does step sizing remain appropriate under fatigue?	Up
Working overhead	How much time is spent writing low-value detail?	Down

Alicia’s step-granularity programme

Alicia’s risk is opaque compound steps.

mark every line containing more than one independent transformation;
identify which of those lines historically produces errors;
split only the high-risk compound lines;
measure whether repair time falls;
retain compression on genuinely stable routines.

Tricia’s step-granularity programme

Tricia’s risk is excessive micro-working.

circle lines that do not change mathematical meaning;
combine safe adjacent micro-steps;
keep state-changing transitions separate;
measure page length and time;
stop compressing when error rate begins to rise.

Kai Kai’s step-granularity programme

Kai Kai’s risk is late-paper over-compression.

identify three transition families that fail under fatigue;
make only those transitions smaller late in timed work;
preserve signs, primes, branch labels and exact states;
audit the final third of every paper separately;
train a late-paper decompression trigger.

Frequently asked questions about showing working and step size

Should I show every algebra step?

No. Show enough to preserve correctness, communicate the route, satisfy assessment requirements and make high-risk transitions inspectable. Reliable low-risk mechanical steps can often be compressed.

How do I know if I skipped too much?

If you cannot quickly reconstruct why the next line follows, cannot locate an error, or combined several independent transformations, the step was probably too large for your current reliability level.

Can writing more steps make me faster?

Yes, when the extra lines reduce checking, rollback and correction time. Overall speed depends on the entire solve-check-repair cycle, not writing time alone.

Why do teachers ask students to show working?

Visible working helps communicate reasoning, supports checking and, in some examinations, can expose creditworthy process. The exact assessment rules depend on the qualification.

Should strong students use fewer lines?

Usually they can compress more because more routines are reliable. But strong performance also includes knowing when to decompress around high-risk transitions, unfamiliar structures and fatigue.

A final step-granularity checklist

I know the dominant mathematical change on each important line.
I do not routinely hide several independent high-risk operations in one transition.
I do not expand every low-risk micro-operation unnecessarily.
Sign-sensitive transformations receive enough visibility.
Fractional algebra receives enough visibility.
Branch entry and exit receive enough visibility.
Substitutions preserve a visible mapping when needed.
Function and derivative levels remain distinct.
Exact and approximate states do not collapse silently.
Important candidate sets appear before filtering.
Rollback distance stays short around high-risk transitions.
My working contains useful inspection points.
I can check a line without reconstructing too many hidden operations.
I compress routines only after they are reliable.
I decompress when uncertainty increases.
I decompress selectively under fatigue.
I do not confuse fewer lines with greater efficiency.
I do not confuse more lines with greater rigor.
My step size supports both exam speed and exam accuracy.
I can answer: “Is this next jump cheap enough to trust if I later need to inspect it?”

The Step-Granularity Laboratory

Step Granularity improves when students practise choosing step size separately from solving difficulty. The laboratory below uses familiar mathematics so the variable being trained is not topic knowledge but the size of each written transition.

Lab 1: split the opaque line

Give a correct but heavily compressed algebra line containing expansion, sign change and collection. Ask the student to rewrite it using the fewest additional states needed to make each high-risk change inspectable.

The goal is not maximum expansion. It is minimum sufficient exposure.

Lab 2: compress the over-written solution

Give a twenty-line solution containing many one-operation micro-steps. Ask the student to compress it while preserving every state needed for checking, proof, branch control and assessment clarity.

Compare time, line count and error detectability before and after compression.

Lab 3: sign-risk granularity

Use expressions with nested negatives and brackets. The student solves the same item twice:

first using their natural step size;
then forcing one visible state immediately after sign distribution.

Track which version is easier to verify and repair.

Lab 4: fraction-risk granularity

Use algebraic fractions where denominator restrictions and simplification coexist. Require separate visible states for:

domain restriction;
common denominator or factor structure;
cancellation;
final simplified expression.

Then test whether any of those states can be safely recombined after reliability improves.

Lab 5: substitution granularity

Give a substitution such as u=x² or a parameter replacement. Ask the student to identify the minimum visible states needed to preserve:

definition;
transformed equation;
candidate solution in the new variable;
return to the original variable;
final validation.

This trains step size around representation handoffs.

Lab 6: derivative-state exposure

Use a calculus question. Compare a compressed solution that jumps directly from f(x) to stationary x-values with one that visibly records f′(x) before solving f′(x)=0.

Ask which version gives better function-level control, checking and classification provenance.

Lab 7: branch-entry granularity

Use a modulus, parameter or piecewise problem. Require a visible branch condition before any branch-specific algebra.

Then compare with a version where the student writes both branch calculations without explicit conditions. Measure re-entry and leakage risk.

Lab 8: exact-to-decimal granularity

Use a long calculation where an exact value is eventually rounded. Ask the student to preserve one authoritative exact state before approximation.

Then test whether later corrections can be made without reconstructing earlier calculator work.

Lab 9: rollback-distance test

Insert one hidden error into a compressed solution and one into a well-granulated solution. Time how long it takes the student to identify the first wrong transition.

Repeat until the student can predict which forms create expensive rollback.

Lab 10: personalised compression map

Build a map of the student’s transformation families:

Transformation family	Current safe granularity	Observed failure	Next target
collecting like terms	compressed	rare	retain
negative brackets	atomic	sign loss	stabilise
algebraic fractions	atomic	cancellation error	retain
simple substitution	chunked	rare	compress
branch transitions	atomic	condition loss	retain

The map makes compression evidence-based rather than personality-based.

The Step-Granularity Failure Atlas

Failure 1: opaque jump

Several independent transformations disappear inside one line.

Repair: split at the highest-risk transformation.

Failure 2: micro-step overload

Every tiny operation receives its own line, increasing page length and visual noise.

Repair: combine low-risk operations into one dominant chunk.

Failure 3: skipped-risk step

A high-failure transition remains invisible because it feels routine.

Repair: expose that transition until its timed error rate becomes low.

Failure 4: state burial

Too many trivial lines make the important mathematical states hard to find.

Repair: compress mechanical detail while preserving semantic states.

Failure 5: long rollback

An error requires reconstructing several hidden operations before the faulty move can be located.

Repair: shorten the interval between visible states around high-risk work.

Failure 6: assessment invisibility

The written route does not expose enough mathematical progress for the assessment context.

Repair: follow official working requirements and make creditworthy process visible where needed.

Failure 7: premature compression

A student compresses a routine before accuracy is stable.

Repair: return temporarily to atomic or chunked steps and re-earn compression through reliable practice.

Failure 8: fatigue blindness

The student keeps early-paper step size even after late-paper error probability rises.

Repair: use selective late-paper decompression triggers.

Failure 9: representation jump

A change of representation is compressed so heavily that the mapping becomes hard to reconstruct.

Repair: expose one bridge state or explicit mapping.

Failure 10: false efficiency

The student celebrates fewer written lines while total solve-check-repair time increases.

Repair: measure total execution cost rather than line count alone.

Granularity states

Exposed: transformation shown in full.
Chunked: one dominant change plus safe cleanup.
Compressed: several reliable operations combined.
Opaque: reconstruction is needed to verify the transition.
Decompressed: a formerly compressed routine deliberately expanded due to risk.

These are training labels rather than formal mathematical categories. Their value is diagnostic: they help students see that step size is adjustable rather than fixed.

Step Granularity Under Full-Paper Pressure

Step size is not fixed across an examination. The safest granularity changes with question difficulty, time debt, fatigue, uncertainty and the cost of a possible error.

The performance target is not a page that always looks the same. It is a student who can resize working deliberately without losing mathematical control.

The step budget

Every visible state consumes time and page space. Every hidden state consumes inspection capacity. The student has a finite step budget.

Spend that budget where the downstream cost of an error is high:

early linked-part results;
parameter values reused later;
branch entry and exit;
sign-sensitive expansion;
fractional algebra;
candidate generation;
representation changes;
exact-to-approximate transitions;
proof or classification steps.

Spend less on stable arithmetic cleanup whose failure is easy to detect and cheap to repair.

Step Granularity under time debt

When a student falls behind time, the instinct is often to remove lines indiscriminately. That can be self-defeating.

Under time debt, preserve minimum viable visibility at:

sign changes;
branch conditions;
substitution definitions;
candidate sets;
derivative states;
parameter thresholds;
final exact/rounded conversion.

Compress routine collection, arithmetic and familiar substitutions more aggressively instead.

Step Granularity under fatigue

Fatigue changes the risk profile. A compound step that was safe early can become too large late.

A practical late-paper rule is:

Do not make every step smaller. Make the historically fragile steps smaller.

This protects speed while acknowledging the student’s actual fatigue curve.

Step Granularity after interruption

When returning to a skipped question, overly compressed earlier work creates reconstruction cost.

Before leaving a hard question, expose one stable re-entry state:

current equation;
current branch;
active substitution;
current candidate set;
next intended transformation.

That single state can be worth more than several compressed lines because it reduces restart cost.

Step Granularity after correction

Corrections reveal whether earlier granularity was well chosen.

If one corrected value forces the student to reconstruct multiple hidden operations, the rollback distance was too large for that region.

Use corrections as data: the next time that transformation family appears, expose one additional state.

Step Granularity and Reliability Testing

Reliability Testing should test not only whether a method works, but whether its compressed written form remains dependable.

fresh algebra;
mixed-topic problems;
timed work;
late-paper placement;
interruption and re-entry;
correction events;
linked-part problems;
full-paper simulation.

If a compressed routine fails only under one of these conditions, the solution is not necessarily to expand it everywhere. Adjust granularity specifically where failure appears.

Step Granularity and Accuracy Reserve

Accuracy Reserve improves when the student uses smaller steps around the transformations most likely to fail under speed.

The objective is selective visibility rather than universal slowness.

Step Granularity and Load Tolerance

Well-sized intermediate states externalise enough information to reduce working-memory demand without flooding the page.

Too-large steps force hidden substeps into memory. Too-small steps force the student to navigate excessive visual detail. Both reduce usable capacity.

Step Granularity and Score Stability

Students with poor granularity often show unstable marks: strong results when questions are familiar, then sudden avoidable losses when the same mathematics appears in denser or longer forms.

Stable step sizing raises the score floor because the written process remains inspectable even when the surface question changes.

Step Granularity and Performance Headroom

When routine steps are compressed appropriately, the page and the student both carry less unnecessary load. When risky steps are exposed appropriately, less headroom is consumed by correction.

Good granularity therefore protects Performance Headroom from both clutter and hidden error.

The full-paper granularity audit

After a fresh paper, audit written transitions rather than only final answers.

Transition event	Audit question	Failure signal
compound algebra line	How many independent changes occurred?	opaque jump
sign-heavy step	Was a useful intermediate state exposed?	sign loss
branch transition	Was the condition visible?	branch leakage
substitution	Was mapping and return visible?	state loss
derivative transition	Was function level visible?	prime/function confusion
routine algebra	Was it over-expanded?	time/clutter cost
correction	How far was rollback?	poor granularity

The granularity heatmap

Transformation family	Fresh	Timed	Late	Full paper
sign/bracket steps	Green?	Amber?	Amber?	Green?
fractional algebra	Green?	Amber?	Amber?	Amber?
substitution handoffs	Green?	Green?	Amber?	Green?
branch transitions	Green?	Amber?	Amber?	Green?
derivative states	Green?	Green?	Amber?	Green?
routine cleanup	Green?	Green?	Green?	Green?

The colours are training shorthand, not official assessment categories.

A one-week step-granularity cycle

Day 1: opaque jumps

Identify compound lines and split only those hiding independent risks.

Day 2: over-expansion

Compress mechanical micro-steps while keeping state-changing transitions visible.

Day 3: sign and fraction risk

Train smaller steps around the student’s highest-frequency algebra errors.

Day 4: substitutions, branches and derivatives

Expose representation and state changes explicitly.

Day 5: rollback testing

Insert errors and measure localisation time under different step sizes.

Day 6: timed mixed work

Use fresh questions and record when time pressure causes over-compression.

Day 7: full-paper transfer

Audit the final third of the paper separately for fatigue-driven step-size changes.

A four-week step-granularity cycle

Week 1: identify opaque jumps and over-expanded routines.
Week 2: calibrate sign, fraction, substitution and branch transitions.
Week 3: earn compression through timed reliability and rollback testing.
Week 4: stress step sizing under fatigue, interruption and full-paper conditions.

The step-granularity readiness gate

Step Granularity is approaching examination readiness when fresh representative work shows that:

high-risk compound steps are rare;
routine work is not unnecessarily expanded;
sign-sensitive transitions remain inspectable;
fractional algebra uses enough visible structure;
branch and substitution handoffs remain clear;
derivative/function states remain distinct;
corrections require short rollback;
checking does not require rebuilding large hidden derivations;
compressed routines remain accurate under time pressure;
late-paper fatigue triggers selective rather than universal decompression;
working remains clear enough for the qualification’s assessment expectations;
total solve-check-repair time is improving rather than merely line count decreasing.

Step Granularity in the final revision phase

Close to the examination, do not redesign the entire writing style. Lock in a small number of personalised triggers:

multiple negatives → one extra state;
nested fractions → one extra state;
branch entry → condition visible;
substitution → mapping visible;
candidate generation → candidate set visible;
exact-to-decimal → exact state visible;
late-paper fatigue → protect the three fragile transformation families.

Step Granularity on examination day

Show your working, but make every line earn its place. Keep routine algebra compact. Slow the written transition—not necessarily the thinking—when signs, fractions, branches, substitutions, parameters, exactness or unfamiliar structure increase risk. Preserve enough states that you can check your work without replaying the entire derivation.

The goal is not a long solution. The goal is a solution whose hidden work never becomes more expensive than the time saved by hiding it.

The step-granularity operating loop

The complete loop is:

Assess Risk → Choose Step Size → Expose Critical State → Transform → Simplify Safely → Inspect → Compress if Reliable → Decompress if Uncertain → Measure Rollback → Recalibrate.

Assess the risk of the next transformation. Choose a step size that matches that risk. Expose any state that protects sign, branch, constraint, notation, function level or precision. Perform the transformation and safe cleanup. Inspect the result. Compress the routine when evidence supports compression. Decompress when uncertainty or fatigue rises. Measure how expensive corrections are. Then recalibrate the next time the same transformation family appears.

That is how “show your working” becomes a performance system instead of a blanket instruction.

The deeper idea: every line is a trade-off

Every written state costs time. Every hidden state costs visibility.

Alicia learns that speed without inspection can produce expensive rollback. Tricia learns that maximum detail can bury the route. Kai Kai learns that the safest step size changes as fatigue changes.

The governing question becomes:

What is the largest step I can take here while keeping the transformation cheap to verify and repair?

When the answer becomes automatic, clear working stops being a generic instruction and becomes a calibrated performance tool.

Additional Mathematics Step Granularity | How to Make Each Transformation Small Enough to Check but Large Enough to Stay Fast