Additional Mathematics Contradiction Localization | Find the Earliest Incompatible State

A long solution can fail in a very specific way: two parts of the mathematics become impossible to hold as true at the same time.

A student obtains x>3 from one part of the derivation and x<1 from another, even though both are supposed to describe the same candidate. A point is calculated to lie on a curve but then fails the curve equation. A parameter is said to produce two distinct real roots while the discriminant has become negative. A trigonometric angle is accepted in Quadrant II while its cosine is simultaneously recorded as positive. An optimisation solution claims a minimum at a point where the derivative test gives the opposite local behaviour. A later part requires a value that contradicts the exact condition established earlier.

At that moment, the student does not merely have “an error somewhere.” The solution has entered an incompatible state.

This article introduces contradiction localization: the examination-performance skill of detecting when a set of solution states cannot all be true together, isolating the smallest meaningful conflict, tracing dependencies backward, locating the earliest incompatible assumption or transformation, repairing locally, and then revalidating only the downstream work that actually depended on the damaged state.

The governing question is:

What is the earliest mathematical state that makes the rest of this solution impossible to keep consistent?

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, permitted calculator use, answer conventions and mark schemes remain authoritative.

This article continues the eduKateSG examination-performance system after Dependency Chains, Constraint Integrity, Checkpoint Architecture, Proof Obligations, Working-State Synchronisation, Solution Transactions and Parallel-Route Isolation. Its canonical job is distinct: debugging an internally inconsistent solution by finding the earliest incompatible state.

The 50-second route

Detect the contradiction. Name the two or more states that cannot all be true together.
Check whether the contradiction is genuine. Make sure the states refer to the same variable, branch, domain, precision and problem context.
Freeze downstream work. Do not continue building on a state already known to be inconsistent.
Find the smallest conflict set. Reduce the contradiction to the fewest states needed to expose the incompatibility.
Trace dependencies backward. Identify what each conflicting state depended on.
Find the earliest shared divergence. Locate the first assumption, transformation, copied value or constraint decision capable of creating the conflict.
Repair locally. Correct the earliest damaged state rather than rewriting the entire solution.
Invalidate only dependent states. Preserve unaffected work.
Regression-test the repair. Recheck every high-value downstream state that depended on the corrected line.
Close the contradiction. The repaired solution should no longer contain mutually incompatible states.

Contradiction does not always mean the mathematics is impossible

There are two fundamentally different situations.

Situation A: the problem genuinely has no solution in the stated regime

The givens and conditions themselves force impossibility. For example, a parameter condition may demand both k>2 and k<1 simultaneously, meaning no admissible parameter exists.

Situation B: the student’s working created the contradiction

The original problem is consistent, but a sign error, illegal cancellation, stale value, branch leak, copied coefficient, premature rounding or invalid assumption has produced incompatible states.

Contradiction localization exists mainly to distinguish these two situations quickly and diagnose Situation B without rechecking the whole paper.

Alicia sees an impossible final answer and restarts everything

Alicia reaches the end of a parameter problem and discovers that the final value violates an earlier condition. She assumes the whole solution is unusable and starts again from the beginning.

But most of her derivation was correct. The contradiction came from one sign reversal eight lines earlier.

Alicia’s repair is localize before restart: identify the incompatible states, trace them backward and repair the earliest damaged dependency rather than discarding correct work.

Tricia notices two incompatible states but checks the latest line first

Tricia obtains a point that supposedly lies on a circle, but substitution shows that it does not. She checks the final substitution repeatedly.

The substitution is correct. The coordinate was already wrong before it arrived.

Her repair is earliest-cause search: move backward through dependencies until the coordinate first became inconsistent with the defining geometry.

Kai Kai fixes the contradiction but leaves damaged downstream states alive

Kai Kai finds a wrong parameter value, corrects it, and continues. But several later equations still contain the old value.

The contradiction has been locally repaired but not propagated through the dependent state.

His repair is repair plus regression: after correcting the earliest fault, identify every dependent state that must be recomputed or revalidated.

Contradiction Localization is not Proof by Contradiction

Proof by contradiction is a formal reasoning technique: assume the negation of a claim and derive impossibility to establish the original claim. Contradiction Localization is different. It is an execution-control system for diagnosing why a worked solution has become internally inconsistent.

One proves a theorem. The other debugs a solution state.

Contradiction Localization is not Constraint Integrity

Constraint Integrity tracks domains, intervals, exactness and admissibility conditions. Contradiction Localization begins when two active states conflict and asks where that conflict originated.

A constraint violation may be the contradiction signal, but localization owns the backward diagnostic search.

Contradiction Localization is not Dependency Chains

Dependency Chains maps how states depend on previous states. Contradiction Localization uses that map in reverse: starting from an impossible joint state and tracing backward toward the earliest cause.

Dependency Chains explains propagation. Contradiction Localization explains fault origin.

Contradiction Localization is not Checkpoint Architecture

Checkpoint Architecture places checks to catch errors. Contradiction Localization is what the student does after a check has exposed an inconsistency and the origin is not yet known.

Contradiction Localization is not Parallel-Route Isolation

Parallel-Route Isolation manages disagreement between concurrent methods. Contradiction Localization owns inconsistency inside one solution state or one merged state, even when no parallel method exists.

What counts as a contradiction signal?

A contradiction signal is any pair or set of active statements that cannot all describe the same valid mathematical state.

x=2 and x=5 for the same unique variable state;
x>3 and x<1 under the same branch;
a point declared on a curve that fails the curve equation;
a candidate accepted while violating the original domain;
an exact value and a rounded value that have drifted beyond permissible tolerance;
a discriminant recorded as negative while two real roots are simultaneously claimed;
a tangent declared perpendicular while its gradient product does not match the required relation;
a stationary point labelled a minimum while local derivative information supports a maximum;
an angle placed in a quadrant inconsistent with the signs of its trigonometric ratios;
a parameter assumed nonzero after later work establishes that it must equal zero.

False contradictions

Not every apparent inconsistency is real. Before debugging, check whether the states are actually meant to coexist.

different branches may legitimately have different values;
different candidate solutions may coexist before filtering;
one state may be exact and another approximate;
one value may belong to x and another to u;
one result may be local and another global;
one result may describe an earlier version that has already been retired.

This is why contradiction localization depends on State Versioning, branch ownership and notation integrity.

The joint-state test

Before declaring contradiction, ask:

Do the statements refer to the same variable or object?
Do they belong to the same branch?
Do they belong to the same version of the solution?
Are they meant to hold simultaneously?
Are they expressed at compatible precision?
Do they inherit the same domain and assumptions?

If the answer is yes and the states still cannot coexist, the contradiction is genuine.

The smallest conflict set

Long solutions may contain dozens of statements, but only a few are needed to expose the contradiction.

Examples:

“x>0” and “x=−3”;
“P lies on y=x²+1” and “P=(2,3)”;
“two distinct real roots” and “discriminant=−4”;
“θ in Quadrant II” and “cos θ>0”.

The smaller the conflict set, the easier the backward search becomes.

Contradiction surface versus contradiction source

The contradiction surface is where the inconsistency becomes visible. The contradiction source is the earlier state that created it.

These are often far apart.

A wrong coefficient near the top of a solution may surface ten lines later as an impossible coordinate. A premature rounding error may surface much later as a failed “hence” result. A branch assumption may surface only when the final candidate is checked against the interval.

Strong debugging searches for the source, not merely the surface.

Backward dependency tracing

Take each conflicting state and ask what immediately produced it.

Then repeat:

State A came from which previous state?
State B came from which previous state?
Where do their dependency histories first intersect?
Where do they first require incompatible assumptions?
What transformation first made one branch inconsistent with the other?

This turns debugging into structured search rather than anxious rereading.

Earliest incompatible state

The earliest incompatible state is the first point in the dependency history where the solution can no longer remain jointly consistent with the trusted problem state.

Typical sources include:

wrong copied sign;
wrong coefficient;
illegal cancellation;
division by a quantity that may be zero;
branch assumption used outside its branch;
candidate promoted before validation;
wrong calculator mode;
stale parameter value;
premature rounding;
forgotten domain restriction;
incorrect return from a substitution;
notation reused for a different object.

Why the earliest cause matters

Repairing a late symptom often leaves the underlying defect alive. Repairing the earliest faulty state corrects all later dependencies at their source.

This does not mean the student should always search back to the first line. The aim is the earliest relevant incompatible state, not the oldest line on the page.

Binary-search thinking for long solutions

In a very long derivation, checking every line sequentially may be slow. A useful strategy is binary-search thinking.

Choose a meaningful midpoint state.
Test whether that state is still consistent with the trusted problem conditions.
If consistent, the defect lies later.
If inconsistent, the defect lies earlier or at that state.
Repeat on the remaining interval.

This works best when meaningful independent checks exist at intermediate nodes.

Contradiction localization in algebra

Algebraic contradictions often emerge as incompatible roots, signs or equations.

High-yield checks include:

substitution into the original equation;
checking whether a cancellation was legal;
checking whether squaring introduced extraneous candidates;
checking coefficient copying;
checking sign changes during transposition;
checking whether an assumed nonzero denominator can actually equal zero.

Contradiction localization in trigonometry

Trigonometric contradictions often involve quadrant, interval, sign and candidate-set mismatches.

angle lies outside required interval;
sign of sine/cosine conflicts with the quadrant;
degree/radian state differs between calculator and written work;
identity transformation creates candidates not validated in the original equation;
principal-value output is mistaken for the full solution set.

Contradiction localization in calculus

Calculus contradictions often appear between derivative state and geometric interpretation.

stationary point claimed where f′(x)≠0;
minimum claimed where local derivative behaviour supports maximum;
tangent gradient conflicts with derivative value;
integrated function fails differentiation back-check;
boundary condition and constant of integration disagree;
optimisation candidate lies outside feasible domain.

Contradiction localization in coordinate geometry

Coordinate geometry supplies strong structural consistency checks.

point does not satisfy its claimed line or curve;
gradient relation conflicts with parallel/perpendicular claim;
midpoint does not lie where the geometry requires;
distance contradicts known radius or length;
intersection candidate satisfies one equation but not the other.

Contradiction localization in inequalities

Inequality contradictions often result from sign flips, boundary loss or branch contamination.

solution interval includes a forbidden boundary;
multiplication/division by a negative quantity reverses the inequality incorrectly;
a critical value is missing;
sign-chart conclusion conflicts with direct test values;
domain restriction and final interval do not intersect.

Contradiction localization in parameter problems

Parameter problems are especially sensitive because one parameter value may control many later states.

parameter value violates an earlier condition;
discriminant regime conflicts with claimed root structure;
graph behaviour contradicts parameter-implied coefficients;
special case was lost during division;
a generic formula was committed at a degenerate parameter value.

Contradiction Localization and Intermediate-Result Criticality

Intermediate-Result Criticality tells the student which upstream nodes deserve early suspicion because they have large downstream influence.

If the contradiction surface is far downstream, begin by checking high-criticality ancestors before disposable arithmetic.

Contradiction Localization and Solution Transactions

A contradiction discovered inside a provisional Solution Transaction can often be contained locally. The route can roll back without contaminating the main solution.

A contradiction discovered after premature commit is more expensive because the damaged state may already have many dependents.

Contradiction Localization and Parallel-Route Isolation

Parallel methods can help reveal contradictions, but only if they remained sufficiently isolated. If Route A imported Route B’s faulty state, their agreement may hide the error rather than expose it.

When isolated routes disagree, the first-divergence method from Parallel-Route Isolation can feed directly into contradiction localization.

Repair scope

Once the earliest faulty state is found, do not automatically rewrite everything after it. Classify downstream states:

Downstream state	Action
directly depends on corrected value	recompute
depends on a different independent branch	preserve
uses same method but not the faulty state	revalidate selectively
high-criticality shared result	strong regression check
retired or unused state	ignore

Regression testing after repair

A repaired solution is not trustworthy merely because the original contradiction disappeared.

Regression testing asks whether the correction created new inconsistencies or left stale downstream states.

Recompute direct dependents.
Recheck constraints and domains.
Recheck high-criticality intermediate results.
Recheck linked-part anchors.
Recheck calculator states if inputs changed.
Recheck the original contradiction signal.
Check whether any new contradiction appears.

The contradiction dashboard

Measure	Question	Desired direction
Contradiction recognition	How quickly are mutually incompatible states noticed?	Up
False-contradiction rate	How often are branch/version differences mistaken for inconsistency?	Down
Conflict-set size	Can the contradiction be reduced to a small diagnostic core?	Down
Localization distance	How far does the student search before finding the earliest cause?	Down
Restart waste	How much correct work is unnecessarily discarded?	Down
Repair completeness	Are dependent states updated after correction?	Up
Regression quality	Are repaired solutions retested for consistency?	Up
Late-paper localization	Does the skill survive fatigue and time pressure?	Up

Frequently asked questions about inconsistent solutions

Does a contradiction always mean I made a mistake?

No. Sometimes the correct conclusion is that no admissible solution exists. First check whether the original givens and conditions themselves create the impossibility.

Should I restart the whole question?

Usually not. Localize the earliest incompatible state first. Restart only when the trusted base itself is uncertain or the dependency structure is too contaminated to recover efficiently.

What if I cannot find the exact error?

Reduce the search interval. Use independent checkpoints at meaningful intermediate states. Determine whether the defect lies before or after each checkpoint until the uncertainty is small enough to inspect directly.

What if two answers are different but both valid?

Then there may be no contradiction. Check whether the problem permits multiple solutions, branches or equivalent representations.

Is checking the final answer enough?

No. A final-answer failure identifies a surface contradiction but may not reveal the earliest source. The efficient repair comes from tracing dependencies backward.

A final contradiction-localization checklist

I can name the states that conflict.
I check whether they really belong to the same branch and version.
I distinguish genuine impossibility from execution error.
I stop building downstream work once inconsistency is known.
I reduce the contradiction to a small conflict set.
I trace dependencies backward rather than rereading randomly.
I search high-criticality ancestors early.
I look for the earliest relevant incompatible state.
I check assumptions, constraints and representation bridges.
I check for illegal transformations.
I check for stale values and notation reuse.
I check precision and calculator state where relevant.
I repair locally rather than automatically restarting.
I invalidate only states that depend on the correction.
I preserve unaffected branches.
I recompute direct dependents.
I regression-test important downstream states.
I recheck the original contradiction signal.
I confirm that no new contradiction was introduced.
I can answer: “What is the earliest state that made these later statements impossible to hold together?”

The Contradiction-Localization Laboratory

Contradiction localization becomes reliable only when students practise debugging deliberately. The goal is not to become suspicious of every line. The goal is to make inconsistency a structured search signal.

Lab 1: smallest conflict set

Give a long worked solution containing one contradiction. Ask the student to identify the smallest set of statements needed to demonstrate that the solution is inconsistent.

Then remove irrelevant lines until only the diagnostic core remains.

Lab 2: false contradiction sorting

Present pairs of apparently conflicting states. Some should be genuine contradictions; others should belong to different branches, variables, versions or precision states.

The student must classify each pair before searching for an error.

Lab 3: contradiction surface versus source

Insert one early sign or coefficient error that does not become visibly impossible until much later. Ask the student to mark:

where the error was introduced;
where the first invalid state appeared;
where the contradiction became visible;
how much downstream work was affected.

Lab 4: backward dependency tracing

Start from an impossible final state and require the student to draw or narrate a dependency path backward until the earliest suspect node is reached.

This trains reverse search rather than sequential rereading.

Lab 5: binary-search debugging

Use a long derivation with independent checkable states at several points. The student must choose a midpoint, test it and repeatedly halve the search interval until the defect is localized.

Compare time against line-by-line checking.

Lab 6: high-criticality ancestor search

Give a contradiction with several possible ancestors. Ask which upstream states deserve inspection first based on fan-out, reuse and correction cost.

The exercise connects contradiction localization with Intermediate-Result Criticality without turning the article into general verification.

Lab 7: local repair radius

After identifying the earliest faulty state, ask the student to classify every later state as recompute, revalidate, preserve or ignore.

The aim is to minimise unnecessary restart while preventing stale-state survival.

Lab 8: contradiction inside a transaction

Create a speculative route that develops an internal contradiction before commit. The student must contain the conflict, roll back the transaction and preserve the trusted main state.

Lab 9: contradiction after route merge

Merge two parallel-route outputs that appear compatible but secretly carry different branch conditions. Ask the student to find why the joint state becomes impossible only after the merge.

Lab 10: regression closure

Repair one injected error, then hide a stale downstream state elsewhere. The student must detect that the repair is incomplete even though the original contradiction has disappeared.

The Contradiction-Localization Failure Atlas

Failure 1: contradiction blindness

The student continues working even after two active states have become mutually impossible.

Repair: freeze downstream expansion as soon as a genuine contradiction is noticed.

Failure 2: false contradiction

Different branches, versions or variables are mistaken for one inconsistent state.

Repair: run the joint-state test before debugging.

Failure 3: surface fixation

The student repeatedly checks the line where inconsistency became visible instead of tracing backward.

Repair: distinguish contradiction surface from contradiction source.

Failure 4: full restart reflex

The entire question is abandoned despite a localizable error.

Repair: localize first, restart only if the trusted base itself is doubtful.

Failure 5: late-cause repair

A downstream symptom is patched while the upstream defect remains active.

Repair: find the earliest relevant incompatible state.

Failure 6: low-value search first

The student inspects disposable arithmetic before high-criticality ancestors.

Repair: prioritize states with large fan-out, branch authority or high correction cost.

Failure 7: under-repair

The source error is corrected but stale dependents remain.

Repair: run a dependency-based regression sweep.

Failure 8: over-repair

Unaffected independent work is recomputed unnecessarily.

Repair: classify repair radius before rebuilding.

Failure 9: contradiction closure without regression

The original inconsistency disappears, so the student assumes the solution is repaired.

Repair: regression-test high-value downstream states and the original answer contract.

Failure 10: impossible-state acceptance

The student treats an internally impossible state as “probably close enough” because time is short.

Repair: incompatibility is structural evidence, not a cosmetic imperfection.

Contradiction-state lifecycle

Consistent: active states can coexist.
Suspicious: a check suggests tension.
Contradictory: a minimal set cannot jointly hold.
Localized: the search interval has been narrowed to the earliest relevant cause.
Repaired: the faulty state is corrected.
Propagated: dependent states are recomputed or revalidated.
Regression-Tested: the solution is checked for residual inconsistency.
Closed: the contradiction no longer survives.

Contradiction Localization Under Full-Paper Pressure

Under full-paper conditions, contradiction localization is primarily a time-saving skill. Its purpose is not exhaustive forensic analysis. Its purpose is to rescue marks by locating the highest-probability source of an impossible state quickly enough to repair what matters.

The debugging budget

A contradiction creates a decision: how much examination time should be spent localizing it?

Spend more debugging time when:

the question carries many remaining marks;
the contradiction is likely caused by one local high-impact fault;
several later parts depend on the damaged state;
the search interval is already narrow;
the repair path is likely shorter than restarting elsewhere.

Spend less when the search is broad, the remaining value is low, or another question offers better expected return.

Contradiction triage under time debt

When behind time, use this order:

Confirm the contradiction is genuine.
Check high-criticality ancestors.
Check branch conditions and special cases.
Check stale copied values.
Check sign-sensitive transformations.
Check calculator mode/input if relevant.
Only then inspect low-risk arithmetic.

This sequence attacks structural faults before local noise.

Contradiction localization under fatigue

Fatigue increases sign mistakes, stale-state reuse, branch leakage and calculator-state errors. Late in the paper, these should move higher in the suspect list.

Use the solution’s structure to compensate for weaker attention: identify what changed recently, what was copied, what crossed a branch boundary and what entered from a calculator.

Contradiction localization after interruption

An interruption can itself create inconsistency when the student resumes from the wrong version or branch. Before deeper debugging, establish:

current authoritative state;
current branch;
current parameter values;
current exactness/precision state;
current calculator mode;
which earlier states have been retired.

Many apparent contradictions disappear once state versioning is restored.

Linked-part contradiction control

In linked questions, a contradiction in part (c) may originate in an anchor result from part (a). Before reworking part (c), test the imported anchor.

If the anchor is wrong, the repair radius may include several later parts. If the anchor is correct, localize inside the current part instead.

Contradiction checkpoints

High-value contradiction checkpoints are states that can cheaply certify broad consistency:

substitution into an original equation;
sign/quadrant checks;
domain and interval checks;
graph location checks;
derivative-to-gradient consistency;
discriminant-to-root-structure consistency;
exact-versus-decimal plausibility;
linked-part anchor verification.

These checkpoints do not replace localization. They help halve the search space.

Repair radius

The repair radius is the portion of downstream work whose validity may have changed after the source correction.

A small repair radius means local recomputation. A large radius may justify restarting a subsection. A global radius is rare unless the source error sits in a foundational parameter, model equation or branch assumption.

The restart threshold

Sometimes restart really is cheaper. Restart a region when:

the earliest trusted state cannot be identified;
several independent contradictions exist;
provisional and committed states are hopelessly mixed;
the repair radius covers nearly the whole section;
reconstructing dependencies would cost more than clean re-execution.

The principle is not “never restart.” It is “restart only after localization shows that restart is economically justified.”

The full-paper contradiction audit

Event	Audit question	Failure signal
contradiction appears	Was downstream work frozen?	error expansion
conflict identified	Was joint-state compatibility checked?	false contradiction
search begins	Were high-criticality ancestors prioritized?	low-value search
source found	Was it the earliest relevant cause?	symptom patch
repair made	Was repair radius mapped?	under/over-repair
dependents updated	Were stale states retired?	residual contamination
regression run	Did the original contradiction disappear without a new one?	incomplete closure
full paper reviewed	How much correct work was unnecessarily restarted?	repair inefficiency

The contradiction-localization heatmap

Control family	Fresh	Timed	Late	Full paper
contradiction recognition	Green?	Green?	Amber?	Green?
false-contradiction control	Green?	Green?	Amber?	Green?
backward tracing	Green?	Amber?	Amber?	Green?
source localization	Green?	Amber?	Amber?	Amber?
repair-radius control	Green?	Amber?	Amber?	Green?
regression closure	Green?	Amber?	Amber?	Amber?

The colours are training shorthand, not official assessment categories.

A one-week contradiction-localization cycle

Day 1: contradiction recognition

Separate genuine incompatibility from different branches, versions and candidates.

Day 2: conflict-set reduction

Compress long inconsistent solutions into minimal diagnostic state pairs or triples.

Day 3: backward tracing

Trace conflicting states through their dependency histories.

Day 4: binary-search debugging

Use meaningful intermediate checks to reduce long search intervals.

Day 5: repair radius

Classify downstream states as recompute, revalidate, preserve or retire.

Day 6: timed localization

Inject faults into long mixed-topic questions and localize them under a debugging budget.

Day 7: full-paper regression

Audit contradiction recognition, restart waste and repair completeness after a fresh paper.

A four-week contradiction-localization cycle

Week 1: joint-state testing, false contradictions and conflict-set reduction.
Week 2: dependency tracing, earliest-cause search and binary-search debugging.
Week 3: repair radius, local repair and regression closure.
Week 4: timed mixed work, interruption, fatigue and full-paper debugging economics.

The contradiction-localization readiness gate

Contradiction Localization is approaching examination readiness when fresh representative work shows that:

genuine contradictions are recognised quickly;
false contradictions from branch/version differences are rare;
students stop downstream expansion after a structural inconsistency appears;
conflict sets are reduced efficiently;
backward dependency tracing is systematic rather than random;
high-criticality ancestors are inspected early;
earliest relevant causes are found without unnecessary full restarts;
repair radius is estimated accurately;
stale dependents are retired after correction;
unaffected work is preserved;
regression testing closes the contradiction cleanly;
the skill survives timed and late-paper conditions.

Contradiction Localization in the final revision phase

Close to the examination, compress the system into eight triggers:

two states cannot coexist? → confirm same branch/version;
genuine contradiction? → freeze downstream work;
large solution? → reduce to smallest conflict set;
searching backward? → inspect high-criticality ancestors first;
long chain? → use midpoint checks;
source found? → map repair radius;
repair complete? → recompute dependents and retire stale states;
finished? → regression-test the original contradiction and final answer contract.

Contradiction Localization on examination day

When two parts of your working cannot both be true, do not panic and do not automatically restart. Confirm that the states really belong together. Stop building on them. Reduce the conflict. Trace backward through the most important dependencies. Repair the earliest faulty state you can justify. Recompute only what depends on it, then make sure the contradiction has actually disappeared.

The contradiction is not merely telling you that something is wrong. It is telling you where to search.

The contradiction-localization operating loop

The complete loop is:

Detect Incompatibility → Confirm Joint State → Freeze Downstream Work → Reduce Conflict Set → Trace Dependencies Backward → Prioritize High-Criticality Ancestors → Locate Earliest Cause → Repair Locally → Map Repair Radius → Recompute Dependents → Regression-Test → Close.

Detect the incompatible states. Verify that they are genuinely meant to coexist. Stop adding new dependencies. Compress the contradiction to its diagnostic core. Trace the conflicting states backward through their dependency histories. Check high-leverage ancestors first. Find the earliest relevant assumption, transformation, value or condition that breaks consistency. Repair that state. Determine which downstream work depends on it. Recompute or revalidate those states while preserving unaffected work. Finally, regression-test the repaired chain until the original contradiction and any newly introduced inconsistency are gone.

That is how contradiction becomes a navigation signal instead of a reason to abandon the solution.

The deeper idea: inconsistency is information

Students often experience contradiction as failure. In advanced examination control, contradiction is also evidence. It narrows the search space.

Alicia learns not to throw away correct work. Tricia learns to search backward toward the source rather than obsess over the surface. Kai Kai learns that repair is incomplete until downstream dependents have been updated.

The governing question becomes:

If these two states cannot both be true, what earlier decision made that incompatibility inevitable?

When students can answer that efficiently, long solutions become easier to debug, easier to repair and far less expensive to restart.

Additional Mathematics Contradiction Localization | How to Find the Earliest Incompatible State When a Long Solution Cannot Be True