Additional Mathematics State Versioning | Keep the Right State Active

Long Additional Mathematics solutions often fail after the student has already corrected the original mistake.

A sign is fixed on line six, but line nine still uses the old value. A parameter is replaced after a better route is found, but a later substitution still carries the discarded parameter. A candidate root is rejected, yet one branch of the working continues to depend on it. A new exact value is established, but an earlier rounded decimal remains active in the calculator. A student changes methods halfway through a question and accidentally combines states from two incompatible routes.

The mathematics may contain a correct state somewhere on the page. The problem is that the solution is still running on an older one.

This guide calls the required discipline state versioning: keeping track of which mathematical state is currently authoritative, which states are provisional, which have been replaced, and which later steps must be recomputed when an upstream state changes.

The term is used as a practical systems metaphor. It does not turn examination mathematics into software engineering. It gives students a precise way to manage stale values, branches, corrections, substitutions and handoffs in long solutions.

This article is global and board-agnostic. It applies to Additional Mathematics, Additional Maths, A-Math and comparable advanced secondary mathematics courses worldwide. The actual syllabus, notation, calculator rules, paper structure, command words, answer requirements and permitted methods of the qualification being taken remain authoritative.

This article continues the eduKateSG examination-performance system after Examination Performance, Score Stability, Accuracy Reserve, Load Tolerance, Decision Latency, Dependency Chains, Fatigue Curve, Performance Headroom, Question Compression, Execution Debt, Reliability Testing and Constraint Integrity. The canonical job here is different: maintaining the correct current state while a long solution changes over time.

The 50-second route

Know which value is authoritative. A corrected state replaces the old one.
Mark provisional states. Do not let an unverified candidate masquerade as final.
Retire stale states visibly. If a value is wrong or superseded, make that clear on the page.
Update descendants. A change upstream can invalidate later lines that depended on the old state.
Protect handoffs. Part-to-part values should carry provenance, exactness and role.
Separate branches. Do not combine states produced under incompatible assumptions.
Recompute selectively. Roll back only to the first state that became invalid.
Keep calculator state aligned with written state. A corrected page with a stale stored value is still wrong.
Recompress after major changes. The current state should stay small enough to understand.
The goal is one source of truth. Long working should never force the student to guess which value the solution is currently using.

Alicia fixes the mistake but not the solution

Alicia differentiates correctly but makes a sign error when solving for a stationary point. Two lines later she notices the mistake and corrects x from -2 to 2.

She feels relieved and continues.

The problem is that the next coordinate had already been calculated using x = -2. Alicia corrects the origin but not the descendant.

The page now contains two versions of the state:

old: x = -2, y calculated from -2;
new: x = 2, but y still stale.

State versioning asks Alicia to do one more thing after correction: identify every later state that inherited the old value.

A corrected origin with stale descendants is not a corrected solution.

Tricia keeps every state and loses the authoritative one

Tricia is cautious. She does not erase anything. When she changes a route, she keeps the old algebra, writes the new route beside it and boxes several intermediate values “just in case.”

Her page becomes a museum of possible states.

Later, she cannot remember which parameter value is current. She substitutes the wrong one into part (c).

Tricia’s problem is not insufficient working. It is insufficient version authority.

A long solution can preserve history without letting history remain active.

Kai Kai changes route and splices two incompatible states

Kai Kai begins a tangent problem using a gradient route. Halfway through, he sees that a repeated-root route will be shorter. He switches.

The new route produces a parameter value under one representation. But Kai Kai carries forward a coordinate derived from the abandoned route before the parameter was resolved.

Each local state looks plausible. Together, they were never simultaneously valid.

State versioning prevents this by making route boundaries explicit. When the governing representation changes, all dependent states must be revalidated before they can join the new branch.

What is a mathematical state?

In this guide, a mathematical state is the collection of information currently being treated as true enough to support the next step.

A state can contain:

current values of variables;
current equation or function form;
current parameter condition;
current candidate set;
current branch or case;
current exactness or precision level;
current domain or interval;
current target;
current trusted handoff from an earlier part.

The state changes as the solution changes.

Authoritative, provisional and retired states

A useful versioning system separates three status levels.

Authoritative: currently accepted as the state the solution should use.
Provisional: a candidate or temporary state not yet fully validated.
Retired: a state that was once used but has been corrected, rejected or superseded.

These labels need not be written literally on the examination script. The student needs a page structure that makes the distinction obvious.

Why provisional states matter

Additional Mathematics often produces values before they are globally valid.

A root may still need interval filtering. A parameter may still need to satisfy a controlling event. A stationary point may still need classification and domain checking. A numerical value may still be waiting for exactness or precision treatment.

Calling such a state provisional prevents premature propagation.

Why retired states matter

Students sometimes believe the safest strategy is to erase the old state completely. That can make diagnosis harder and create accidental loss of useful structure.

A better approach is to retire the stale state clearly.

Examples:

single strike-through rather than ambiguous overwriting;
arrow to corrected value;
box around new authoritative value;
small note such as “use this” or “corrected” where allowed and useful;
clear separation between abandoned and active method branches.

The page should preserve enough history for recovery while leaving no doubt about the current truth.

State versioning is not the same as dependency chains

Dependency Chains asks how an error travels through descendants. State versioning asks which version of each state is currently authoritative after the chain changes.

The two systems meet during correction. Dependency mapping tells the student what may have been contaminated. State versioning tells the student which repaired values now replace the contaminated ones.

State versioning is not the same as constraint integrity

Constraint Integrity asks whether a state remains valid under all conditions that still have authority. State versioning asks whether the solution is using the newest valid state rather than an older one.

A value can be current but inadmissible. A value can be admissible but stale. The systems protect different failure modes.

State versioning is not the same as execution debt

Execution Debt tracks recurring operational cost. State versioning can reduce that cost because the student no longer repeatedly asks which value is correct or reconstructs what changed after a correction.

But state versioning owns one narrower job: preventing old states from remaining operational after the mathematics has moved on.

The version lifecycle

A state can move through several stages:

Created: a new value, expression or branch appears.
Provisional: the state has not yet passed all checks.
Validated: enough conditions have been satisfied for the state to become authoritative.
Propagated: downstream work begins using it.
Challenged: a contradiction, check or better route calls it into question.
Corrected or replaced: a new state supersedes it.
Descendants updated: affected downstream states are recomputed.
Retired: the old state remains visible only as history.

Long solutions become safer when students recognise these transitions.

The single-source-of-truth rule

At any important handoff, there should be one clearly identifiable authoritative value or expression.

If the page contains x = 3, x = 4 and x = 5 from different attempts, the student must not rely on memory to know which one is current.

Use a clean visual authority signal consistent with exam-writing norms: box, underline, arrow or clear rewritten line.

The page should answer the question: If I return here two minutes later, what value will I use?

State provenance

Authority is stronger when the state’s origin is clear.

“from part (a)”;
“stationary candidate”;
“after interval filter”;
“corrected derivative”;
“parameter from repeated-root condition”;
“exact value used in next part.”

Provenance does not require verbose prose. A compact label can prevent a stale or inappropriate state from being reused.

State scope

A state may be authoritative only within one branch, one subpart or one condition.

For example, a candidate value of k may be valid under case A but not case B. An expression may be authoritative before a domain filter but provisional after a transformation. A rounded value may be acceptable for one final subpart but not for another linked exact calculation.

Authority must therefore include scope.

State handoffs

Part-to-part handoffs are one of the highest-value places for version control.

A handoff should carry:

value or expression;
role;
exactness or precision state;
constraints that still matter;
whether the state is final or provisional.

A handoff that carries only a number is fragile.

State replacement

When a new state replaces an old one, the replacement should be explicit.

A useful sequence is:

old state challenged → new state established → authority transferred → affected descendants updated → old state retired.

Skipping “authority transferred” is what creates pages where both old and new values remain operational.

State rollback

Rollback means returning to the last trustworthy state after a later line becomes unreliable.

Do not restart the whole question unless necessary. Find the last state whose validity and provenance are still trusted.

Then rebuild only from there.

This is selective recovery rather than global restart.

Rollback depth

Rollback depth is how far upstream the correction must go.

local algebra slip: rollback one or two lines;
wrong candidate filter: rollback to candidate set;
wrong derivative: rollback to derivative state and update descendants;
wrong model: rollback to representation or formulation stage;
wrong route: rollback to the last state independent of the abandoned method.

The deeper the rollback, the more descendants may need recomputation.

Shallow rollback is a performance skill

Students often restart too much because they cannot identify the last trusted state. That wastes time and increases fatigue.

Good state architecture creates rollback points: clean equation, boxed exact handoff, labelled candidate set, validated parameter condition.

These states function like recovery checkpoints.

Stale-state propagation

A stale state is an old state that should have been retired but continues to feed later work.

Common examples include:

old sign;
old parameter;
old coordinate;
old exact/decimal form;
old branch;
old calculator-stored value;
old assumption after a route switch.

Stale-state propagation can survive even after the student “fixes the mistake” because the descendants are not automatically updated.

The descendant-update rule

Whenever an upstream state changes, ask:

Which later lines used the old state?
Which later lines are independent of it?
Which handoffs must be replaced?
Which constraints or candidate sets change?
Which final answers must be recomputed?

This keeps correction bounded but complete.

The affected-descendant map

During training, draw arrows from important states to the lines that depend on them.

Example:

corrected parameter k → intersection coordinate → gradient → line equation → final part.

If k changes, every descendant after the arrow must be reconsidered.

This extends the logic of Dependency Chains into correction control.

State versioning in linked multi-part questions

Linked questions often create official handoff states. Part (a) produces a result specifically designed for part (b). Part (b) creates a state reused in part (c).

When one earlier result changes, the version boundary can cross several parts.

A robust structure is:

box or clearly mark final part (a) state;
carry exact form if still active;
label the role of the state;
if corrected later, explicitly replace the handoff;
audit every later part that imported it.

Part boundaries do not protect the solution from stale-state inheritance.

State versioning in parameter problems

Parameter problems are particularly vulnerable because one value can control an entire downstream structure.

A provisional parameter may be used to construct a curve, gradient or intersection before full admissibility is checked.

Keep parameter states explicitly provisional until the controlling event is verified.

State versioning in trigonometry

Trigonometry commonly creates candidate sets that change after interval filtering.

The authoritative state should progress through:

transformed equation → candidate family → interval-filtered candidates → final solution set.

Do not let the broad candidate family remain active after the filtered final set is established.

State versioning in calculus

Calculus produces several natural version boundaries:

original function;
derivative;
stationary equation;
candidate coordinate;
classified stationary point;
contextual interpretation.

If the derivative changes, all later states depending on it must be reviewed. If only the classification changes, the coordinate may remain authoritative.

State versioning in coordinate geometry

Coordinate geometry can generate many nearby values: x-coordinate, y-coordinate, gradient, parameter, midpoint, intercept and line equation.

Unlabelled numbers are dangerous because stale values look identical to current ones.

Use concise role labels at major handoffs.

State versioning in modelling

Modelling questions move through representations: context → variables → constraint equation → objective function → calculus state → candidate → interpreted answer.

Each representation can replace part of the previous state while inheriting important meaning and constraints.

A correction to the model equation may invalidate the entire downstream calculus chain even when the differentiation itself was flawless.

State versioning in proof

Proof and justification problems contain logical states rather than only numerical ones.

If one claim is withdrawn, every later claim depending on it must be re-examined. An old lemma cannot remain operational after its assumptions have changed.

State versioning in proof is premise control.

State versioning in inequalities

Inequality work often moves from expression → critical values → sign regions → final interval set.

Once the sign analysis is complete, the critical values alone are no longer the final authoritative answer state. The interval set is.

This distinction prevents students from returning an earlier state simply because it appears cleaner.

Exactness versions

The same mathematical quantity can exist in several representations:

exact symbolic form;
high-precision calculator form;
final rounded form.

These are not interchangeable at every stage.

The exact symbolic form may remain authoritative for linked calculations while the rounded form is authoritative only for final presentation.

State versioning prevents the presentation version from replacing the calculation version too early.

Calculator-state versioning

Where calculators are allowed, the device contains hidden state.

stored variables;
previous answer;
angle mode;
graph window or table state where applicable;
expression history.

A corrected written page does not automatically correct the calculator.

When an important value changes, update or clear the relevant device state so the hidden version does not reintroduce the old value later.

The hidden-state mismatch

Hidden-state mismatch occurs when the page and calculator disagree about the current value.

This can be especially dangerous because the calculator output may look precise and authoritative.

Use simple discipline: after a major correction, confirm that any stored value or active expression depending on the old state has been refreshed.

Route-state versioning

Changing route can change which states remain valid.

Before switching:

identify the last route-independent state;
preserve original constraints;
retire assumptions belonging only to the old route;
build the new route from the shared state;
do not splice in old descendants unless revalidated.

This makes method switching controlled rather than improvisational.

Branch-state versioning

Some questions deliberately split into cases.

Each branch has its own local state. Values derived under branch A should not be copied into branch B unless the dependency is genuinely shared.

At convergence, combine only results that remain valid under the final problem conditions.

Branch convergence

When two branches lead to the same later state, the solution can reconverge.

But reconvergence should be earned, not assumed.

Check that the merged state truly has the same value, same constraints and same interpretation in both branches.

State conflicts

A state conflict occurs when two current-looking values disagree.

Do not average, guess or choose the cleaner one.

Resolve the conflict by provenance:

where did each value come from?
which assumptions supported it?
which route is still active?
which constraints were checked?
which state has stronger evidence?

State conflicts are a signal to stop propagation until authority is resolved.

The authority transfer rule

When a new state becomes authoritative, make the transfer visible immediately.

A page that contains a correct new value but visually emphasises the old one is a future error waiting to happen.

The new state should become easier to find than the old state.

The state ledger

For training, a small ledger can make version problems visible.

State	Status	Source	Used by
k = 3	provisional	candidate equation	not yet propagate
k = 2	authoritative	constraint-checked	intersection, gradient
x = -1	retired	sign error	must update descendants
exact surd	authoritative for calculation	part (a)	part (b)
2.73	presentation-only	rounded output	final answer only

The ledger is a diagnostic training device, not an examination form to complete.

Version count

Some questions naturally create many versions of one quantity. Too many active-looking versions increase ambiguity.

Good page architecture reduces the number of states that still look live.

History can remain visible. Authority should remain singular.

State drift

State drift occurs when the current working slowly diverges from the original mathematical meaning.

An exact parameter becomes a rounded decimal, then a calculator-stored number, then a copied value without its sign condition. Each local transition seems small. The final state may no longer represent the original quantity faithfully.

State versioning works with Constraint Integrity to prevent this drift.

Version drift after correction

Correction can create drift if the new state is inserted but old descendants remain.

The page now contains a hybrid solution composed of multiple versions.

The repair is a descendant audit, not another local check.

The state checksum

At a major transition, ask:

Current value? Current route? Current branch? Current constraints? Current exactness?

This five-part checksum is short enough to use at high-value handoffs.

When to version explicitly

Most routine questions do not need explicit version management. Use stronger state controls when the question contains:

linked parts;
multiple candidate values;
parameter solving;
method switching;
case splits;
important corrections;
exact-to-decimal transitions;
calculator-stored values;
long dependency chains;
multi-stage modelling.

Versioning effort should scale with ambiguity and dependency.

When versioning becomes overkill

Tricia’s failure mode is turning every number into a managed object. That adds execution debt.

Do not label every intermediate line. Protect only states whose replacement or confusion could materially affect later work.

The operating principle is high-value authority, low-cost notation.

State versioning and question compression

Question Compression reduces the problem into a small mathematical state. State versioning keeps that reduced state current as the problem evolves.

After a major correction, recompress the solution:

What is true now? What is no longer true? What remains unresolved? What is the next state?

Recompression is one of the cheapest ways to prevent stale-state confusion.

State versioning and reliability testing

Reliability Testing should include correction and recovery, not only clean success.

A method is stronger when the student can:

detect a wrong state;
replace it cleanly;
identify affected descendants;
update hidden calculator state;
continue without restarting the entire question.

Recovery reliability includes version control.

State versioning and fatigue

Late in an examination, stale-state risk rises because students compress working, hold more information mentally and are more likely to return to earlier values without checking authority.

Late-paper state controls should be simple:

box corrected authoritative values;
strike through stale values once;
label branch transitions;
refresh calculator storage after major corrections;
use one-line handoffs between parts.

Complex version notation will not survive fatigue. Visual clarity will.

State versioning and score stability

Stale-state failures create avoidable score variance. A student may perform well on papers where few corrections are needed and collapse on papers that require more route changes or complex handoffs.

Improved version control raises the score floor by making correction less destructive.

The state dashboard

Measure	Question	Desired direction
State conflicts	How often do two current-looking values disagree?	Down
Stale-state reuse	How often is a retired value used again?	Down
Descendant misses	How often is an upstream correction not propagated?	Down
Rollback depth	How far must the student restart after an error?	Shallower where appropriate
Handoff fidelity	Do linked parts use the right authoritative state?	Up
Branch contamination	Are states mixed across incompatible cases?	Down
Hidden-state mismatch	Does calculator/device state disagree with written state?	Down
Recovery time	How long from detected error to stable new state?	Down

Alicia’s state-versioning programme

Alicia corrects origins but misses descendants.

mark important dependency handoffs;
when a state changes, trace all descendants;
recompute only affected lines;
box the new authoritative value;
retire the old value visibly;
test late and under time.

Her success metric is a correction that actually propagates through the whole solution.

Tricia’s state-versioning programme

Tricia preserves too much history and lets several states look active.

identify only high-value authoritative states;
retire superseded states clearly;
keep one source of truth per handoff;
reduce unnecessary boxes and annotations;
test whether re-entry becomes faster.

Her mature system is sparse version authority.

Kai Kai’s state-versioning programme

Kai Kai’s risk is route splicing.

mark route-switch boundaries;
identify the last route-independent state;
discard assumptions unique to the old route;
revalidate any carried values;
test method switching under realistic pace.

His speed remains useful because the switch becomes clean rather than hybrid.

Frequently asked questions about correcting long A-Math solutions

Why do I still get the final answer wrong after correcting my mistake?

You may have corrected the origin but left descendants using the old state. After any important correction, identify every later line that depended on the old value and update only those lines.

Should I erase wrong working?

Usually it is safer to retire it clearly rather than leave ambiguous overwriting. Exact examination-script conventions vary, but the practical goal is that the current state is obvious and the corrected route remains readable.

How do I know how far to restart?

Return to the last state that remains trustworthy and independent of the error. Restart from there, not automatically from the beginning.

Why do I use the wrong value in later parts?

Your handoff may lack authority or provenance. Mark the final value from the earlier part clearly and preserve its exactness or role when it is reused.

How do I stop mixing two methods?

When switching routes, return to the last state shared by both routes. Carry original constraints forward, but retire assumptions and descendants that belonged only to the abandoned route.

Can a calculator keep an old wrong value?

Yes. Stored variables, previous answers or expression history can remain stale after the written page is corrected. Refresh important device state after major corrections.

A final state-versioning checklist

I know which values are authoritative.
I distinguish provisional candidates from final states.
I retire superseded states visibly.
I can identify the origin of important handoff values.
I preserve exactness state where it still matters.
I know which branch or case a state belongs to.
I do not combine descendants from incompatible routes.
I know the last trustworthy state when I need to roll back.
I restart only as far as necessary.
I audit descendants after upstream corrections.
I update linked parts when an earlier handoff changes.
I keep calculator storage aligned with corrected written states.
I can resolve conflicting current-looking values by provenance.
I make the new authoritative state easier to find than the old one.
I recompress after major route or state changes.
I protect state authority late in the paper.
I test version control under realistic time.
I can recover after a correction without restarting the whole question.
I preserve history without letting stale history remain active.
My page has one clear mathematical source of truth at every important handoff.

The State Versioning Laboratory

State versioning improves fastest when students practise recovery deliberately rather than waiting for accidental mistakes in full papers. The laboratory below isolates the exact moments where stale-state failures begin: corrections, handoffs, branch changes, route switches, exactness changes and hidden calculator storage.

The goal is not to create artificial bureaucracy. It is to make one principle automatic: after a state changes, the rest of the solution must know.

Lab 1: authoritative-state marking

Give the student a worked solution containing several intermediate values, one rejected candidate and one corrected value. Ask them to mark only the states that should still be considered active.

The exercise should distinguish:

candidate from final answer;
old value from corrected value;
branch-local state from globally reusable state;
calculation form from presentation-only rounded form.

This trains authority recognition before the student has to perform any correction.

Lab 2: stale-descendant detection

Present a long solution where one upstream value has been corrected but two downstream lines still use the old state.

The student must identify every stale descendant and explain why it became stale.

Useful structures include:

parameter → coordinate → gradient → line;
derivative → stationary point → function value → classification;
part (a) exact value → part (b) substitution → part (c) interpretation;
candidate roots → filtered set → graph feature.

The student learns that correction creates a dependency audit, not merely a new local line.

Lab 3: minimum rollback

Give the student a solution with an error at a known point and ask where the restart should begin.

Possible answers might be:

one algebra line back;
the derivative state;
the candidate set;
the model equation;
the last route-independent state.

Then compare the student’s rollback depth with what is actually required. Students who restart too far are paying recovery debt. Students who restart too little may preserve contamination.

Lab 4: handoff authority

Use a three-part question where part (a) produces an exact result, part (b) transforms it and part (c) depends on the transformed state.

The student must identify what should be carried at each boundary:

the value;
the role;
the exactness or precision state;
any surviving constraint;
whether it is final or still provisional.

Then intentionally correct part (a) and ask which later parts must change.

Lab 5: route-switch hygiene

Give a question with two legitimate methods. Ask the student to begin one route, stop halfway and switch to the other.

The student must identify:

the last state common to both routes;
the assumptions unique to route A;
which values from route A may survive;
which descendants must be retired;
what state route B should start from.

This is especially useful for students who are mathematically flexible but operationally messy.

Lab 6: branch contamination

Use a case-splitting question. Let branch A produce one local value and branch B produce another. Insert a deliberate error where the value from A is copied into B.

The student must identify why the transplanted state is invalid even though the value itself may be mathematically reasonable.

The key lesson is that a state includes its assumptions. A number without its branch condition is incomplete.

Lab 7: exactness-version control

Give a linked problem in which the same quantity appears in three versions:

exact symbolic form;
high-precision numerical form;
final rounded presentation form.

Ask which version is authoritative at each stage.

The student should learn that the final rounded version can be correct for presentation while remaining inappropriate for later calculation.

Lab 8: calculator hidden-state audit

Where the assessment permits calculators, give a question in which a stored value is later corrected on paper. Ask the student to continue without being reminded to update the calculator.

Observe whether the old stored state reappears.

This laboratory exposes hidden-state mismatch and can be extended to:

angle mode;
stored variables;
previous answer;
table or graph settings where applicable;
expression history.

The calculator should support the current mathematical state, not preserve a secret earlier version.

Lab 9: state-conflict resolution

Give a page containing two plausible current-looking values for the same quantity. The student must resolve the conflict without recomputing the whole problem.

They should use provenance:

which value came from the current route?
which value passed the relevant constraints?
which value was derived after the latest correction?
which value matches the authoritative handoff?

This trains evidence-based authority rather than visual preference.

Lab 10: state compression after correction

After a substantial correction, ask the student to write a four-line state summary:

what is true now?
what has been retired?
what remains provisional?
what is the next state needed?

The exercise prevents the solution from remaining mentally tied to its historical path.

Lab 11: timed correction

Once correction is accurate while untimed, add realistic pace. The student detects a prepared error, rolls back, updates descendants and resumes.

Measure:

time to identify last trusted state;
rollback depth;
number of descendants updated;
whether stale values remain visible as active;
time until a stable new state is established.

The goal is not instant correction. It is bounded, complete correction.

Lab 12: late-paper correction

Place a state-versioning challenge late in a long mixed session. Students often perform clean versioning while fresh and revert to mental tracking under fatigue.

Compare early and late performance. Does the student:

forget to retire the old value?
skip descendant updates?
fail to clear calculator state?
restart too much?
mix branches?

The late version determines whether state control is truly examination-ready.

The State Failure Atlas

Different versioning failures require different repairs. “I used the wrong value” is too broad.

Failure 1: authority ambiguity

Two or more states look equally current.

Repair: one visible source of truth at high-value handoffs.

Failure 2: provisional-state propagation

A candidate is used downstream before all relevant validity checks are complete.

Repair: delay propagation until the candidate becomes authoritative.

Failure 3: stale-state reuse

A retired value reappears later.

Repair: make retirement visible and make the replacement easier to find.

Failure 4: descendant-update failure

An upstream state changes but dependent lines remain untouched.

Repair: affected-descendant map and correction checklist.

Failure 5: excessive rollback

The student restarts the entire question after a local error.

Repair: identify the last trustworthy state and preserve unaffected work.

Failure 6: insufficient rollback

The student corrects too locally and leaves contamination upstream or downstream.

Repair: determine the first state whose validity changed, then audit descendants.

Failure 7: route-splice failure

States from two methods are combined without verifying compatibility.

Repair: route boundary and last route-independent state.

Failure 8: branch contamination

A state valid in one case is copied into another.

Repair: attach branch condition to local states until convergence.

Failure 9: hidden-state mismatch

The written page is corrected but the calculator retains the old state.

Repair: refresh device state after major corrections.

Failure 10: presentation-version takeover

A rounded or simplified presentation state replaces the more appropriate calculation state too early.

Repair: preserve calculation authority separately from final presentation authority.

Failure 11: history overload

The page contains so much retained working that current authority becomes hard to see.

Repair: sparse high-value version markers rather than annotating every line.

Failure 12: authority without provenance

A value is boxed but the student no longer knows what it represents.

Repair: concise role labels at important handoffs.

The state-versioning readiness ladder

Clean-state use: student can use one authoritative state when no correction occurs.
Local correction: student can replace one value and update immediate descendants.
Long-chain correction: student can update several downstream states.
Branch control: student keeps case-specific states separated.
Route-switch control: student can change methods without splicing incompatible descendants.
Hidden-state control: calculator and written states remain aligned.
Timed recovery: correction remains bounded under realistic pace.
Late recovery: version control survives fatigue.
Full-paper transfer: corrections inside fresh papers do not destabilise later performance.

The ladder is a training model, not an official assessment scale.

State Versioning Under Full-Paper Pressure

State versioning becomes examination-ready only when it survives the conditions that make version control hardest: time debt, fatigue, interruptions, method switching, revisiting skipped questions and correcting work without destabilising the rest of the paper.

The real objective is not a beautifully versioned page. It is a paper that can absorb local corrections without turning one mistake into a system-wide collapse.

The recovery corridor

A recovery corridor is the smallest path from a detected problem back to a stable current state.

It contains four points:

last trusted state;
first invalid transition;
new authoritative state;
affected descendants.

If the student can identify those four points quickly, recovery remains bounded.

The last-trusted-state test

When something looks wrong, students often ask, “Where did I make the mistake?” A more operational question is:

What is the last thing on this page that I still trust?

This anchors rollback. It prevents total restart when most of the structure remains valid.

The first-invalid-transition test

After locating the last trusted state, find the first transition that no longer follows.

sign changed incorrectly;
wrong value substituted;
candidate accepted too early;
branch condition lost;
derivative formed incorrectly;
rounded value replaced exact state;
route assumption became invalid.

The first invalid transition defines the rollback boundary more precisely than the final wrong answer does.

The new-authority test

Correction is incomplete until the new state is visually and logically authoritative.

Ask:

is the corrected value clearly visible?
has the old value been retired?
have relevant constraints been restored?
does the calculator agree?
is the branch or route still the same?

Only then should the solution resume propagation.

The affected-descendant test

A correction can change one descendant or many.

Use a simple audit:

Which later values directly used the corrected state?
Which later conclusions depended on those values?
Which branches remain independent?
Which final answer components must be updated?

The aim is neither “redo everything” nor “change one number and hope.” It is selective propagation repair.

State versioning under time debt

When a student is behind time, they are tempted to correct mentally. The old value remains written, the new value remains in memory, and the next line is supposed to remember which one is current.

This is precisely when version control is most valuable.

Use a minimum viable protocol:

strike stale state once;
write corrected state once;
mark the first affected descendant;
continue from the corrected branch.

Four clear actions are often cheaper than trying to maintain invisible mental versions.

State versioning under fatigue

Fatigue increases state confusion because earlier working becomes harder to scan and mental tracking becomes less reliable.

Late-paper controls should therefore rely on visual contrast and fixed triggers rather than subtle notation.

corrected value → one clear authority mark;
old value → one clear retirement mark;
new branch → visible separation;
linked handoff → concise role label;
calculator correction → immediate refresh.

The simpler the versioning system, the more likely it survives the final third of the paper.

State versioning after a skipped question

When a question is left unfinished and revisited later, the student faces a version problem even if no error occurred.

The earlier state may no longer be mentally active.

Before leaving, preserve a re-entry capsule:

current authoritative equation or value;
current branch or route;
still-active constraint;
what has already been rejected;
next plausible move.

On return, the capsule becomes the current state without requiring complete reconstruction.

State versioning after discovering a late error

A student may discover near the end that an earlier answer feeding later work was wrong.

The worst response is panic-driven global rewriting.

Instead:

identify the corrected authoritative state;
identify the widest dependent descendants;
update high-value downstream answers first;
preserve visible method where follow-through credit may exist under the relevant mark scheme;
avoid destroying correct independent work.

Exact marking treatment is board-specific, so current mark schemes remain authoritative. The performance principle is controlled repair rather than global destruction.

State versioning and partial recovery

Sometimes there is not enough time to recompute every descendant.

Prioritise descendants by value and dependency:

final answers that can be updated cheaply;
later parts worth substantial marks;
high-confidence recalculations;
states that unlock several later corrections.

Leave low-value expensive rewrites if they would endanger independent marks elsewhere.

The correction budget

Every correction consumes time. The student needs a correction budget.

Before beginning a large rollback late in a paper, ask:

How many marks can this correction plausibly recover?
How deep is the rollback?
How many descendants must change?
What independent work remains undone?
Is the corrected route now trustworthy?

The aim is rational recovery, not perfection at any cost.

The rollback decision tree

Is the error local? Fix locally and continue.
Did the error feed one later state? Fix origin and that descendant.
Did it feed a chain? Roll back to first invalid state and rebuild chain.
Did it affect the model or route? Return to the last route-independent state.
Is time too short? Prioritise high-value descendants and independent remaining marks.

This is a practical exam-recovery heuristic, not an official marking algorithm.

State versioning and answer checking

Checking should verify state authority, not merely recompute arithmetic.

High-value checking questions include:

Did I use the final filtered candidate or an earlier candidate set?
Did this part use the corrected value from the previous part?
Did the calculator still contain an old stored number?
Did I switch route and accidentally carry a route-specific state?
Did I round a value before all linked work was complete?

This form of checking is targeted state verification rather than wholesale re-solving.

State versioning and Performance Headroom

Performance Headroom is preserved when corrections remain local and cheap. A student who must restart entire questions after small errors has little recovery headroom.

Versioned states create recovery checkpoints. Recovery checkpoints reduce the cost of correction and leave more capacity for the rest of the paper.

State versioning and Accuracy Reserve

Accuracy Reserve is supported when corrections do not introduce new stale-state errors.

A student may detect the original mistake but lose accuracy during the repair because the new state and old state coexist. Strong versioning turns correction into a controlled transition.

State versioning and Load Tolerance

Long linked questions create state load. Versioning reduces the active working set by clarifying which states remain current and which history can be ignored.

That does not make the mathematics easier. It makes the current state smaller.

State versioning and Decision Latency

A stale or ambiguous state increases decision latency because the student must first reconstruct what is true before choosing the next move.

Clear authority means the next decision starts from the correct present rather than from a forensic investigation of the page.

State versioning and Constraint Integrity

These two systems form a pair:

Constraint Integrity: Is this state valid?
State Versioning: Is this the current valid state?

Both questions are necessary in long solutions.

The full-paper state audit

After a fresh full paper, review every substantial correction or route switch.

Event	What to inspect	Failure signal
Correction	Were descendants updated?	Old value survives
Route switch	Was last shared state used?	Hybrid route
Branch split	Were local states separated?	Cross-branch contamination
Linked part	Was authoritative handoff used?	Wrong or rounded version
Calculator correction	Was hidden state refreshed?	Old stored value returns
Skipped question return	Was re-entry state preserved?	Full reconstruction

The audit should identify a small number of recurring versioning mechanisms, not produce an endless list of isolated mistakes.

The state-versioning heatmap

Versioning task	Fresh	Timed	Late	Full paper
Authority marking	Green?	Green?	Amber?	Green?
Descendant update	Green?	Amber?	Amber?	Amber?
Route switch	Green?	Amber?	Amber?	Green?
Branch control	Green?	Green?	Amber?	Green?
Calculator sync	Green?	Green?	Amber?	Amber?
Rollback depth	Green?	Amber?	Amber?	Amber?

The colours are only a training shorthand. The heatmap shows which state-control tasks fail under realistic conditions.

A one-week state-versioning cycle

This is an illustrative structure for a student whose mathematical content knowledge is already sufficient for the selected questions.

Day 1: authority

Practise identifying authoritative, provisional and retired states in worked solutions.

Day 2: correction

Repair local errors and update descendants without restarting whole questions.

Day 3: handoffs

Use linked multi-part questions and exactness-version control.

Day 4: branches and route switches

Practise branch separation and controlled route changes.

Day 5: hidden state

Synchronise calculator and written states after corrections where calculators are permitted.

Day 6: timed recovery

Add realistic pace and measure rollback depth and recovery time.

Day 7: late/full-paper transfer

Test whether the student can preserve authority after sustained work and inside a fresh representative paper.

A four-week state-versioning cycle

Week 1: authority, provenance and handoffs.
Week 2: rollback, descendant updates and exactness versions.
Week 3: branch control, route switching, calculator-state synchronisation and timed correction.
Week 4: late-position, skipped-question re-entry and full-paper transfer.

Once version control is stable, move it to maintenance and let normal mixed papers provide regression tests.

The state-versioning readiness gate

A student is approaching examination-ready state control when fresh representative work shows that:

authoritative states are easy to identify;
provisional candidates do not propagate prematurely;
retired states are not reused;
upstream corrections trigger appropriate descendant updates;
rollback stops at the last trustworthy state rather than the beginning;
route switches do not create hybrid solutions;
branch-local states remain separated;
calculator and written states remain synchronised;
linked parts use the correct authoritative handoff;
exactness and presentation versions remain distinct where needed;
version control survives realistic time;
version control survives late-paper fatigue;
one correction no longer destabilises the rest of the paper.

No single correction proves readiness. The evidence should recur across fresh questions, different topics and full papers.

State versioning in the final revision phase

Close to the examination, simplify. Do not introduce an elaborate notation system.

Keep only the highest-value rules:

one authoritative value per handoff;
retire stale states clearly;
after correction, update descendants;
after route switch, return to shared state;
after calculator correction, refresh hidden state;
after a large correction, recompress what is true now.

The final system should be compact enough to run under pressure without conscious bureaucracy.

State versioning on examination day

The paper will not be perfectly clean. A strong candidate does not need error-free working; they need controlled recovery.

If a value changes, transfer authority. If an upstream state changes, update descendants. If a route changes, return to the last shared state. If a calculator contains the old version, refresh it. If the page becomes confusing, recompress the current state before moving again.

The goal is not to avoid every correction. It is to ensure the newest valid mathematics remains in control.

The state-versioning operating loop

The complete loop is:

Create → Mark Provisional → Validate → Make Authoritative → Propagate → Detect Conflict → Roll Back → Replace → Update Descendants → Retire Old State → Recompress → Continue.

Create the state. Keep it provisional until enough checks pass. Make the validated state authoritative. Let downstream work use it. If a contradiction appears, locate the last trusted state. Replace the invalid version. Update the descendants that inherited it. Retire the old state. Recompress what is true now. Then continue.

That loop turns correction from an interruption into a normal part of reliable mathematical execution.

The deeper idea: a long solution is a moving system

Students often think of a written solution as a permanent record: once a line is written, it simply remains part of the answer.

But long mathematics behaves differently. States are created, tested, replaced, filtered and propagated. Some values remain authoritative. Some are provisional. Some become stale. Some must be rolled back. Some carry into the next part. Some belong only to one branch.

Alicia learns that correcting the first wrong line is not enough. Tricia learns that keeping every historical state visible does not mean every state should remain active. Kai Kai learns that switching methods requires a clean authority boundary.

The governing question becomes:

What is the newest valid state, and has every dependent part of the solution been updated to use it?

When the answer is clear, long solutions become easier to correct, easier to re-enter and much harder for stale mathematics to corrupt.

Additional Mathematics State Versioning | How to Keep the Right Mathematical State Active Through Long Solutions