Additional Mathematics Intermediate-Result Criticality | Verify High-Leverage Results First

Not every intermediate result deserves the same amount of checking.

A student derives a small arithmetic value that is used once in the next line. Another result becomes the parameter carried through four later parts. A derivative is used to locate stationary points, classify behaviour and build a tangent equation. A trigonometric angle becomes the input to a second identity. A coordinate found early determines a gradient, a line, an intersection and finally an area. A rounded decimal is copied into every later calculation. One wrong intermediate state can therefore cost one mark, while another can corrupt half a question.

This difference is intermediate-result criticality: how consequential an intermediate mathematical state becomes if it is wrong and then reused.

The governing question is:

Which result is about to become important enough that I should verify it more strongly before I let the rest of the solution depend on it?

This guide is global and board-agnostic. It applies to Additional Mathematics, Additional Maths, A-Math and comparable advanced secondary mathematics courses worldwide. Official syllabus requirements, mark schemes, calculator rules and exactness conventions remain authoritative.

This article continues the eduKateSG examination-performance system after Dependency Chains, Checkpoint Architecture, State Versioning, Reliability Testing, Proof Obligations, Step Granularity and Working-State Synchronisation. Its canonical job is distinct: ranking intermediate states by the consequences of trusting them.

The 50-second route

Notice reuse. A result used many times deserves more scrutiny than one used once.
Notice fan-out. If one result feeds several later branches, its criticality rises.
Notice depth. A result near the start of a long dependency chain can contaminate many later steps.
Notice correction cost. If discovering an error later would force major rework, verify earlier.
Notice uncertainty. A high-consequence result derived through a fragile method deserves stronger checking.
Notice irreversibility. Rounding, calculator handoffs and compressed transformations can make later reconstruction harder.
Promote deliberately. Do not let a provisional result become a trusted reusable state without enough evidence.
Use stronger checks selectively. Independent verification belongs at high-criticality nodes, not everywhere.
Protect exact states. High-criticality values should usually retain the best available precision until the answer contract permits otherwise.
Audit downstream blast radius. Ask what would have to be redone if this result were wrong.

Alicia checks the final answer but not the result that created it

Alicia is careful at the end of a question. She substitutes the final answer back and checks the presentation.

But an earlier value of k was used in four later lines. That value came from a sign-sensitive equation and was never independently checked.

The final answer check detects that something is wrong, but now the repair search spans most of the solution.

Alicia’s repair is criticality-before-finality: verify the result at the point where it becomes a high-leverage dependency, not only after every consequence has already been built.

Tricia checks everything equally

Tricia responds to uncertainty by checking nearly every line.

She spends the same effort verifying a disposable arithmetic simplification as she spends verifying a parameter that controls three later cases.

Her checking is thorough but economically weak.

Tricia’s repair is a verification hierarchy: stronger checks go to results with greater downstream consequence, while low-criticality states receive lighter checks or none at all.

Kai Kai trusts the calculator value because it looks precise

Kai Kai obtains 2.483917… from a calculator and uses it repeatedly in later work.

The number looks authoritative because it has many digits. But the expression entered into the calculator contained a copied coefficient error.

Precision is not criticality control. A highly precise wrong value can have a very large blast radius.

Kai Kai’s repair is to verify high-reuse calculator outputs against the source expression before promoting them into reusable states.

Intermediate-Result Criticality is not Dependency Chains

Dependency Chains maps how states depend on one another and how errors propagate. Intermediate-Result Criticality asks which nodes in that dependency structure deserve the strongest protection because their failure would matter most.

Dependency Chains describes the network. Criticality ranks the nodes.

Intermediate-Result Criticality is not Checkpoint Architecture

Checkpoint Architecture decides where and how to place verification gates. Intermediate-Result Criticality supplies one reason a gate deserves to be strong: the state being promoted has high downstream consequence.

Checkpoint Architecture is the verification design system. Criticality is a priority signal inside that system.

Intermediate-Result Criticality is not Reliability Testing

Reliability Testing asks whether a method, routine or performance survives varied conditions. Intermediate-Result Criticality operates inside a specific solution and asks which derived states deserve priority before reuse.

Intermediate-Result Criticality is not State Versioning

State Versioning determines which result is current and authoritative. Criticality determines how much evidence should be demanded before a result is trusted enough to become an important authoritative state.

Intermediate-Result Criticality is not Working-State Synchronisation

Working-State Synchronisation keeps mind, page and tool aligned. Criticality asks which aligned state deserves extra verification before extensive downstream reuse.

What counts as an intermediate result?

An intermediate result is any derived mathematical state that is not yet the final required answer and that can influence later work.

a numerical value;
a parameter;
a coordinate;
a gradient;
a derivative;
a stationary point;
a factorisation;
a transformed equation;
a candidate root;
a trigonometric angle;
an interval boundary;
a branch conclusion;
a geometric length or ratio;
a constant of integration;
a simplified expression reused later.

Not all intermediate results are equally critical. The key is what happens after they are accepted.

Five drivers of criticality

1. Downstream fan-out

Fan-out is the number of distinct later states that depend directly on the result.

A value used once has low fan-out. A parameter used in a derivative, a tangent equation, a coordinate and a final area has high fan-out.

2. Dependency depth

Depth is how far the result sits from the final answer through chained dependencies.

An early error can survive through many transformations and become harder to locate later.

3. Reuse count

A result reused repeatedly deserves more protection because each reuse multiplies exposure.

Reuse can occur across one long part or across several linked parts.

4. Correction cost

If discovering the error later would require rebuilding large amounts of working, criticality rises.

A wrong number used only in the next subtraction is cheap to repair. A wrong constant used throughout an integration-and-geometry synthesis question is expensive.

5. Derivation fragility

A result derived through sign-sensitive algebra, multiple branches, calculator entry, rounding or unfamiliar manipulation deserves stronger suspicion than one obtained by a stable routine.

A practical criticality model

A training model can estimate criticality using:

Criticality ≈ Fan-out × Reuse × Error Cost × Repair Cost × Derivation Risk.

This is not a formal mathematical formula. It is a decision aid. The exact numbers do not matter. The ranking does.

Criticality classes

Class	Description	Typical verification
C1 Disposable	used once, low consequence	mental plausibility
C2 Local	feeds a small nearby step	quick local check
C3 Reusable	used several times or across a short chain	direct recheck or substitution
C4 High-Leverage	feeds multiple branches or linked parts	independent verification where possible
C5 Structural	controls the architecture of much of the solution	strong verification before promotion

The labels are a training system, not official assessment terminology.

The promotion gate

A provisional result becomes more dangerous when the student begins reusing it.

Before promotion into a high-reuse state, ask:

How many later steps depend on this?
How hard would it be to repair later?
How fragile was the derivation?
Can I verify it independently?
Should I preserve the exact form?
Is this result clearly recorded and synchronised?

If the result is high-criticality, promotion should require stronger evidence.

Verification strength should scale with consequence

A C1 arithmetic state may need no explicit check. A C5 structural state may deserve an independent route, substitution back into the original relation, dimensional or graphical plausibility, or another strong signal.

The principle is:

Do not spend equal checking effort on unequal risk.

Independent checks are especially valuable at critical nodes

Repeating the same fragile derivation can reproduce the same error. High-criticality results benefit from checks that use a different signal.

substitute back into the original equation;
compare with a graph;
use a second algebraic route;
check sign or magnitude;
verify a coordinate geometrically;
differentiate or integrate back where appropriate;
check a trigonometric value against quadrant and interval;
compare exact and decimal forms;
use structural properties rather than recomputation.

Critical path versus critical result

A critical path is a long chain of dependent work. A critical result is a node whose correctness strongly controls what follows.

A result can be critical because it sits early on a long path, because it fans out into many paths, or both.

Fan-out nodes

A fan-out node feeds several independent downstream calculations.

Examples:

a parameter used in two later functions;
a coordinate used for gradient, distance and area;
a stationary point used for tangent, normal and classification;
a solved angle used in two later identities;
a factorisation used to identify roots and sign intervals.

Fan-out nodes are natural verification priorities.

Gateway results

A gateway result determines which method or branch becomes available next.

Examples include:

a discriminant deciding root regime;
a sign deciding modulus branch;
a derivative deciding stationary points;
a parameter threshold deciding case structure;
a coordinate determining geometric configuration.

Gateway results are critical because an error changes not only a value but the route itself.

Carrier results

A carrier result is transported through many later lines with little modification.

Constants, parameters, coordinates, gradients and exact surds often behave this way.

Carrier results deserve careful initial verification because their errors can remain visually quiet while contaminating many later states.

Multiplier results

A multiplier result enters formulas repeatedly and amplifies its own error through repeated use.

A slightly wrong rounded value reused several times can accumulate visible drift.

High-criticality multiplier results should remain exact or at least high precision until final presentation whenever the qualification and problem permit.

Linked-part anchors

Some examination questions deliberately make part (b) depend on part (a), and later parts depend on both.

The result that crosses the boundary between parts is a linked-part anchor.

Before carrying it forward, ask:

is it exact enough?
is it the intended result?
is there a stated “hence” relationship?
did it depend on an unverified candidate?
will the next part amplify any error?

Parameter criticality

Parameters are often high-criticality because one derived parameter value can reshape every later equation.

A parameter may change:

root structure;
graph position;
gradient;
stationary points;
branch conditions;
domain restrictions;
tangent equations;
final numerical answers.

A parameter derived early and reused widely is almost never a disposable state.

Calculus criticality

In calculus, a derivative can be a structural result.

If f′(x) is wrong, the stationary points, gradient conditions, tangent or normal equations and classifications may all be wrong.

Therefore a derivative that feeds several later tasks deserves stronger verification than a derivative used once and discarded.

Trigonometric criticality

An intermediate angle can be high-criticality when later identities, lengths, areas or transformed expressions depend on it.

Verify high-leverage angles against:

required interval;
quadrant;
sign;
degree/radian state;
exactness where relevant;
original trigonometric relation.

Coordinate geometry criticality

A coordinate can feed gradient, distance, midpoint, line equation, circle equation and area calculations.

That makes coordinates common fan-out nodes. A quick substitution into the defining relation can be cheaper than repairing five later consequences.

Inequality criticality

Critical values divide the number line into sign regions. One wrong critical value changes several intervals at once.

Before building a sign chart or interval solution from a critical value, verify its derivation and domain status.

Optimisation criticality

Optimisation often contains several critical states:

the model equation;
the constraint substitution;
the derivative;
candidate stationary points;
endpoint candidates;
classification or comparison.

Criticality changes across the chain. The model equation can be more important than the final arithmetic because every later state inherits it.

Exactness and criticality

High-criticality results should generally preserve the best available mathematical state until the calculation no longer depends on them.

Premature rounding is especially dangerous at multiplier and carrier nodes because the approximation is reused repeatedly.

Calculator outputs and criticality

A calculator result that is used once may be checked lightly. A result that becomes a linked-part anchor or repeated input deserves source-expression verification, mode verification and precision control.

Working-State Synchronisation keeps the tool result attached to its source. Intermediate-Result Criticality decides how strongly that source-result pair should be verified before reuse.

Criticality can rise during a solution

A result can begin as local and later become important.

For example, an angle first used in one line may later become the given value for two linked parts. At that moment its criticality rises.

Criticality is therefore dynamic. Re-evaluate when reuse expands.

Criticality can fall

Once a result has served its final dependency and will not be used again, its future criticality falls even if it was previously important.

This matters because checking effort should move forward with the solution rather than remain attached to retired states.

The blast-radius question

Before trusting an uncertain intermediate result, ask:

If this is wrong, how much of the remaining solution becomes wrong with it?

This single question often identifies verification priorities faster than a formal scoring system.

The repair-cost question

Also ask:

If I discover this error five minutes later, how much work must I undo?

High repair cost is a reason to check earlier.

The promotion checksum

Before a result becomes a major reusable state, use:

Source correct? Constraints intact? Precision sufficient? Independent signal? Recorded clearly? Ready for reuse?

This is a training checksum rather than formal mathematical terminology.

Criticality and Proof Obligations

A high-criticality result can also carry unresolved proof obligations. A candidate parameter that has not yet been validated should not be promoted merely because later working needs a parameter.

Proof Obligations determines what remains owed. Criticality determines how costly it would be to ignore that obligation before reuse.

Criticality and Step Granularity

High-criticality derivations often deserve slightly finer Step Granularity because hidden compound steps make verification and later repair harder.

The point is not to expand every line. It is to expose enough of the high-criticality derivation that the result can be trusted economically.

Criticality and Working-State Synchronisation

Once a high-criticality result is verified, it must remain synchronised across mind, page and tool. A verified result that is copied wrongly downstream loses the value of the verification.

The criticality dashboard

Measure	Question	Desired direction
High-criticality miss rate	How often is a major reusable result left weakly checked?	Down
Low-value overchecking	How much time is spent checking disposable states?	Down
Critical-node detection	How reliably are fan-out and gateway results recognised?	Up
Independent-check use	Do important states receive independent verification where practical?	Up
Repair distance	How much downstream work is usually invalidated by discovered errors?	Down
Promotion discipline	Are provisional results validated before heavy reuse?	Up
Precision retention	Are important reusable states kept exact or sufficiently precise?	Up
Linked-part anchor accuracy	Are cross-part results dependable before reuse?	Up

Alicia’s criticality programme

Alicia’s risk is checking late instead of checking leverage.

mark results reused three or more times;
identify fan-out nodes;
verify those nodes before further expansion;
measure whether late repair time falls;
reduce redundant end-of-solution checking when earlier critical gates are reliable.

Tricia’s criticality programme

Tricia’s risk is equal checking effort everywhere.

label intermediate states C1–C5 during review;
compare checking time by class;
reduce checking on C1/C2 states;
strengthen C4/C5 independent checks;
audit total checking time and error containment.

Kai Kai’s criticality programme

Kai Kai’s risk is trusting precise-looking calculator outputs.

mark calculator values that become reusable;
attach them to source expressions;
verify mode and input for C4/C5 outputs;
retain sufficient precision through repeated use;
audit every calculator-originated error for blast radius.

Frequently asked questions about important intermediate results

Should I check every intermediate answer?

No. Checking should scale with consequence. Disposable states may need only plausibility. High-leverage states deserve stronger evidence before extensive reuse.

How do I know a result is high-criticality?

Look for fan-out, repeated reuse, long dependency depth, expensive later repair, fragile derivation and route-changing effects.

Is an early result always more important?

No. Position matters only through consequence. A late result can be highly critical if it feeds several final branches, while an early disposable arithmetic value may remain low-criticality.

What is the best check for a critical result?

Prefer an independent signal when practical: substitution, graphical consistency, structural reasoning, alternative algebra, sign/magnitude checks or another route that does not simply repeat the same fragile derivation.

Why not just check at the end?

Because a wrong high-criticality result can generate many later states. End-only checking may detect the failure after repair has become expensive.

A final intermediate-result criticality checklist

I recognise results that feed several later steps.
I recognise results reused across linked parts.
I recognise gateway results that change route or branch.
I distinguish disposable states from structural states.
I consider repair cost before deciding how strongly to check.
I consider derivation fragility.
I preserve enough precision in high-criticality states.
I do not promote unvalidated candidates into widely reused states.
I use independent checks at high-leverage nodes where practical.
I do not spend equal checking time on unequal risk.
I verify important calculator outputs at their source.
I verify parameter values before broad reuse.
I verify coordinates that become geometric fan-out nodes.
I verify derivatives that feed several calculus conclusions.
I verify interval boundaries before building sign regions.
I revisit criticality when a result’s reuse expands.
I stop spending checking effort once a state is retired.
I can estimate the blast radius of a possible error.
I can estimate the cost of discovering the error later.
I can answer: “Is this result important enough that I should prove to myself it is right before I build on it?”

The Intermediate-Result Criticality Laboratory

Criticality becomes reliable only when students learn to rank intermediate results before the consequences become obvious. The laboratory below trains that ranking directly.

Lab 1: mark the blast radius

Take one worked multi-stage question. Circle every intermediate result and draw arrows to every later line that depends on it.

The student then ranks the circled states from smallest to largest blast radius.

The objective is not to solve again. It is to see where one wrong state would spread furthest.

Lab 2: fan-out counting

Give a solution containing several reusable results. Count direct downstream dependents for each one.

one use → low fan-out;
two or three uses → moderate fan-out;
several independent uses → high fan-out.

Then compare fan-out with how much checking the student naturally gave that result.

Lab 3: repair-cost prediction

Before checking a suspicious state, ask the student to predict how many later lines would need to be redone if it were wrong.

Then reveal an error and measure the actual repair.

This trains the connection between verification timing and future rework.

Lab 4: criticality classes

Give ten intermediate states from mixed topics. The student labels each C1 to C5 and justifies the label using fan-out, reuse, derivation fragility and repair cost.

Disagreement is useful. The goal is not one perfect classification but increasingly accurate risk reasoning.

Lab 5: independent-check matching

For each high-criticality state, choose the cheapest independent verification signal.

Result type	Possible independent check
root	substitute into original equation
coordinate	test defining curve/line relation
angle	quadrant, interval and original trig relation
derivative	differentiate again carefully or compare structure
parameter	substitute into original conditions
interval boundary	test sign/domain behaviour around boundary

Lab 6: gateway-result detection

Use questions where one result changes the route: discriminant sign, modulus sign, parameter threshold or a stationary-point condition.

The student must identify the gateway before continuing and explain why route-changing states deserve more verification than ordinary carrier states.

Lab 7: linked-part anchor audit

Take a question with parts (a), (b), (c) and (d). Mark every result that crosses from one part into another.

For each anchor, record:

exact or approximate;
verified or unverified;
number of later uses;
conditions inherited;
repair cost if wrong.

Lab 8: precision criticality

Use one value repeatedly in a long numerical chain. Solve once with premature rounding and once with exact or high-precision retention.

Compare final drift and identify why multiplier states deserve different precision discipline from disposable states.

Lab 9: overchecking audit

Review a timed solution and mark every explicit check. Classify the state being checked.

If the student spent more time checking C1/C2 states than C4/C5 states, redesign the checking budget.

Lab 10: promotion-gate simulation

Pause a worked solution immediately before an intermediate result is reused several times.

The student must decide:

what class is this result?
what is its expected blast radius?
what is the cheapest independent check?
what precision should be retained?
is it ready for promotion?

The Intermediate-Result Failure Atlas

Failure 1: critical-node blindness

A high-leverage result is treated like ordinary local arithmetic.

Repair: identify fan-out and future reuse before continuing.

Failure 2: end-only checking

The student waits until the final answer to verify a chain built on an early fragile state.

Repair: move strong checks upstream to high-criticality nodes.

Failure 3: uniform checking

All intermediate states receive similar checking effort regardless of consequence.

Repair: scale check strength with criticality class.

Failure 4: provisional promotion

An unvalidated candidate becomes a widely reused authoritative value.

Repair: promotion gate before broad reuse.

Failure 5: repeated-method checking

The student “checks” by repeating the same derivation and reproduces the same error.

Repair: use an independent signal where practical.

Failure 6: precision erosion

A high-reuse value is rounded too early and the approximation is propagated repeatedly.

Repair: preserve exact or sufficient precision until the dependency chain ends.

Failure 7: gateway neglect

A route-changing state is weakly checked even though it determines which branch or method follows.

Repair: treat route-changing results as structural until proven otherwise.

Failure 8: linked-part anchor neglect

A result crosses into later parts without verification, sufficient precision or inherited conditions.

Repair: audit the anchor before crossing the part boundary.

Failure 9: static criticality

The student assumes a result’s importance never changes.

Repair: re-rank when reuse or downstream dependence expands.

Failure 10: retired-state overchecking

Checking effort remains attached to a state after all of its dependencies have ended.

Repair: move verification attention forward with the live dependency structure.

Critical-result lifecycle

Derived: intermediate state first appears.
Rated: consequence and fragility are estimated.
Provisional: result is available but not yet heavily trusted.
Verified: evidence is sufficient for its criticality level.
Promoted: result becomes a reusable authoritative state.
Propagated: downstream work depends on it.
Retired: no remaining active dependency needs it.

The lifecycle is a training model. It separates “I calculated this” from “I have enough reason to build half the question on this.”

Intermediate-Result Criticality Under Full-Paper Pressure

Criticality control becomes most valuable when the paper is long enough that checking everything is impossible. Under time pressure, the question is no longer “Can I verify this?” but “Which result gives me the largest reduction in future error for the seconds I spend verifying it?”

The verification budget

A student has limited checking time. Spend the strongest checks on states with high consequence and meaningful uncertainty.

A useful hierarchy is:

C5 structural: strongest affordable verification before reuse.
C4 high-leverage: independent or high-yield check where practical.
C3 reusable: direct recheck or substitution if cheap.
C2 local: plausibility or quick local check.
C1 disposable: usually continue unless something looks wrong.

The exact labels matter less than the principle: checking effort should follow leverage.

Criticality under time debt

When behind time, students often remove checks randomly. A better response is to preserve checks at high-blast-radius nodes and compress checking elsewhere.

Under time debt, protect:

parameter values reused later;
linked-part anchors;
gateway results that determine route or branch;
derivatives feeding several later conclusions;
coordinates or gradients with several downstream uses;
calculator outputs reused repeatedly;
critical interval boundaries;
model equations in optimisation.

Reduce checking on low-impact arithmetic whose failure is local and cheap to repair.

Criticality under fatigue

Late in the paper, derivation fragility rises even if downstream consequence stays the same. A result that was safely C3 early may deserve C4 treatment when signs, copying or calculator entry become less reliable.

Criticality therefore combines consequence with current execution risk.

Criticality after interruption

When returning to a skipped question, first identify the highest-criticality unresolved state.

Do not resume by continuing the nearest unfinished algebra automatically. Resume from the state whose correctness matters most to everything that follows.

Criticality after correction

If a corrected state was high-criticality, the correction should trigger a broad dependency review. If it was disposable, the repair can remain local.

This prevents both under-repair and unnecessary global restarting.

Criticality and Checkpoint Architecture

Criticality tells Checkpoint Architecture where strong gates are likely to have the highest yield.

High-yield checkpoint positions include:

before a result is reused across several lines;
before a value crosses into a later part;
before a parameter is substituted into multiple expressions;
before a derivative becomes the basis for several conclusions;
before an approximate value replaces an exact one in a long chain;
before a gateway result commits the solution to a branch.

Criticality and Dependency Chains

Dependency Chains makes the downstream topology visible. Criticality turns that topology into an action priority.

Two nodes can have the same number of dependents but different criticality if one is derived through a fragile route or is much more expensive to repair later.

Criticality and Reliability Testing

Reliability Testing should test whether students still identify high-leverage states under changed question surfaces.

fresh parameter problems;
mixed calculus and coordinate geometry;
linked multi-part questions;
calculator-heavy work;
late-paper placement;
questions with misleading disposable details;
problems where a late state suddenly becomes high-criticality.

If the student only recognises critical nodes in familiar templates, the skill has not yet transferred.

Criticality and Accuracy Reserve

Accuracy Reserve improves when checking is concentrated where one error would otherwise create many later errors.

Selective verification preserves both time and correctness better than uniform checking.

Criticality and Load Tolerance

Students cannot hold the importance of every state in working memory. A simple visual cue can help during training:

circle high-reuse values;
star linked-part anchors;
underline gateway results;
box C5 structural states after verification.

These marks are training aids, not required exam notation. With practice, the prioritisation becomes mental and faster.

Criticality and Score Stability

High-criticality errors create unusually large score swings because one mistake can damage several marks or parts.

Reducing the frequency of these errors raises the score floor even if the total number of small arithmetic errors does not change much.

Criticality and Performance Headroom

When the student knows which states matter most, checking decisions become faster. This preserves Performance Headroom for difficult reasoning instead of spending it on blanket verification.

The full-paper criticality audit

After a fresh paper, do not only classify wrong answers. Identify the highest-criticality states in every long question and ask whether they were recognised and protected.

Event	Audit question	Failure signal
reusable result appears	Was future reuse noticed?	critical-node blindness
result fans out	Was verification strengthened?	weak promotion
linked part begins	Was anchor checked and precise?	anchor neglect
gateway result appears	Was route-changing state verified?	gateway neglect
calculator result reused	Was source/mode verified?	tool-origin blast radius
rounding occurs	Was criticality considered before precision loss?	precision erosion
correction discovered	Was repair scope proportional to criticality?	under/over-repair
checking time spent	Was effort concentrated on high leverage?	verification misallocation

The criticality heatmap

Criticality family	Fresh	Timed	Late	Full paper
fan-out detection	Green?	Green?	Amber?	Green?
gateway detection	Green?	Amber?	Amber?	Green?
promotion discipline	Green?	Amber?	Amber?	Amber?
independent-check choice	Green?	Amber?	Amber?	Green?
linked-anchor protection	Green?	Green?	Amber?	Green?
precision retention	Green?	Amber?	Amber?	Green?

The colours are training shorthand, not official assessment categories.

A one-week criticality cycle

Day 1: fan-out and reuse

Map downstream dependents and identify repeated-use states in worked solutions.

Day 2: repair cost

Predict and then measure how much rework follows injected intermediate errors.

Day 3: criticality classes

Rank C1–C5 states across algebra, trigonometry, calculus and geometry.

Day 4: independent verification

Match high-criticality result types to cheap independent checks.

Day 5: linked parts and gateways

Train anchor checks and route-changing result verification.

Day 6: timed mixed work

Use fresh questions and record whether verification effort follows leverage under time pressure.

Day 7: full-paper transfer

Audit the paper for high-criticality misses, not merely wrong final answers.

A four-week criticality cycle

Week 1: fan-out, dependency depth, reuse and criticality classes.
Week 2: independent checks, promotion gates and precision control.
Week 3: linked-part anchors, gateways and correction-cost management.
Week 4: timed mixed work, late-paper stress and full-paper regression testing.

The intermediate-result criticality readiness gate

Intermediate-Result Criticality is approaching examination readiness when fresh representative work shows that:

high-fan-out states are recognised quickly;
gateway results receive stronger verification before route commitment;
linked-part anchors are checked before reuse;
provisional candidates are not promoted prematurely;
high-criticality calculator outputs are verified at their source;
important values retain sufficient precision through dependency chains;
independent checks are chosen economically;
low-value overchecking is decreasing;
late-paper fatigue does not erase verification priority;
correction scope matches the criticality of the faulty state;
full-paper errors have smaller downstream blast radius;
checking time produces more prevented rework per minute.

Intermediate-Result Criticality in the final revision phase

Close to the examination, compress the whole system into a few triggers:

used again? → criticality rises;
used in several places? → verify stronger;
changes route? → gateway check;
crosses into next part? → anchor check;
hard to repair later? → check now;
calculator output reused? → verify source;
rounded and reused? → preserve precision;
no more dependencies? → stop spending checking time there.

Intermediate-Result Criticality on examination day

Do not try to check everything. Notice which values are about to become structural. If one result will be reused repeatedly, carried into later parts, change the branch, or be expensive to repair later, spend a few seconds proving it deserves your trust. Use lighter checking on disposable states.

The strongest students are not those who check the most. They are those who check the states whose failure would cost the most.

The intermediate-result criticality operating loop

The complete loop is:

Derive → Estimate Consequence → Classify Criticality → Choose Verification Strength → Verify Independently if Needed → Preserve Precision → Promote → Reuse → Monitor Expanded Fan-Out → Retire.

Derive the state. Estimate how much later work will depend on it and how expensive a future correction would be. Classify its criticality. Choose a verification strength that matches the consequence and fragility. Use an independent signal when the state is important enough. Preserve sufficient precision. Promote the result into an authoritative reusable state only after the evidence is adequate. Reuse it while monitoring whether new dependencies raise its importance. Once no live dependency remains, retire the state and move verification attention forward.

That is how checking becomes risk-weighted rather than habitual.

The deeper idea: verification should follow leverage

Examination checking is a resource-allocation problem. Time is limited, but intermediate states do not carry equal consequence.

Alicia learns to verify before blast radius expands. Tricia learns that rigorous checking is selective, not uniform. Kai Kai learns that calculator precision cannot substitute for source verification.

The governing question becomes:

Where would one wrong value do the most damage?

When students can answer that quickly, checking becomes faster, earlier and more protective.

Additional Mathematics Intermediate-Result Criticality | How to Identify Which Values Deserve Stronger Verification Before You Reuse Them