Independent Recomputation¶
Cross-check computation — instantiates Self-Checking Operation
Re-derives the same result by a deliberately different method and compares the two derivations, so a mistake in either path shows up as a disagreement.
Independent Recomputation produces the same answer twice by two different routes and then asks whether the routes agree. The two derivations must be genuinely independent — a different algorithm, a different tool, a different person, ideally a different set of assumptions — because the whole power of the technique comes from the improbability of two unrelated methods making the same mistake. What makes this this mechanism, and not merely adding a check digit, is that it re-does the work: it doesn't compare the output against an encoding of itself, it compares one full computation against an entirely separate computation of the same quantity. Agreement within tolerance is the evidence of correctness; a divergence is the alarm, and — crucially — it says someone is wrong without yet saying who.
Example¶
A structural engineer sizes a steel beam for a mezzanine and computes its maximum bending stress by hand, using the closed-form Euler-Bernoulli formula on the back of the load schedule. Independently, a colleague builds a finite-element model of the same beam in analysis software and reads off the peak stress there. The two numbers are supposed to describe the same physical quantity by two unrelated routes — pencil-and-paper mechanics versus a meshed numerical model — so they should land within a few percent of each other.
They don't: the hand calc says the beam is comfortably safe, the FEA says it is overstressed by nearly a third. The disagreement is the whole point. Neither result is trusted; the two engineers trace the gap and find a units slip in the hand calc — a distributed load entered in kN/m where the formula expected N/m. Corrected, the two methods converge, and only then does the beam size get signed off. Had only one method run, the plausible-but-wrong hand figure would have gone straight to fabrication.
How it works¶
- Re-derive by a genuinely different path. A second method computes the same target quantity — a different algorithm, an inverse ("multiply back to check the division"), a separate tool, or an independent analyst — chosen so its likely errors don't overlap the first's.
- Compare within a declared tolerance. Exact match for discrete results; a stated band for numerical ones, sized to the legitimate difference between methods so real disagreements aren't lost in rounding.
- Withhold the result on divergence. A mismatch blocks acceptance and triggers reconciliation; neither figure is trusted until the paths converge or the discrepancy is explained.
- Expose which paths ran and whether they agreed. The output carries its verification state — "cross-checked, agreed" versus "single-source, unverified" — so downstream users know how much the number has been vouched for.
Tuning parameters¶
- Independence of the second path — how much the methods share (same formula, same tool, same person). The less they share, the fewer errors are common to both — but true independence costs more to build.
- Agreement tolerance — the band within which the two results count as matching. Too tight floods reconciliation with rounding noise; too loose lets real errors hide inside the band.
- Coverage — every result cross-checked vs. a sampled fraction. Full coverage catches every discrepancy at double the compute; sampling trades assurance for cost.
- Reconciliation protocol — what happens on divergence: which path is presumed authoritative, or whether a third tiebreaker is invoked.
When it helps, and when it misleads¶
Its strength is catching reasoning errors that self-consistency checks miss — a mistyped constant, a wrong sign, a formula misapplied — because such a mistake produces an output perfectly consistent with itself yet wrong, and only an independent derivation exposes it. It is the general form of what software calls N-version programming.[n1]
Its failure mode is correlated error: if the two paths secretly share a flawed assumption, a common library, or the same misread specification, they can agree confidently on the same wrong answer, and the matching results manufacture false assurance. The classic misuse is a "second check" that just re-runs the first method — two passes down one road, which catches transcription slips but blesses any error baked into the method itself. The guarding discipline is to engineer the independence deliberately (different math, different tools, different people) and to be most suspicious precisely when a hard problem's two paths agree too cleanly.
How it implements the components¶
independent_recalculation_path— the second, deliberately dissimilar derivation of the same quantity is the mechanism's core; agreement across paths is its evidence of validity.accept_reject_retry_route— a divergence blocks acceptance and routes the result into reconciliation until the paths converge or the gap is explained.check_status_exposure— the result is tagged with its verification state (cross-checked and agreed vs. single-source) so downstream users can weight it.
It does not implement redundant_or_independent_signal or automatic_correction_rule — appending an extra encoding of the same output and repairing it in place is Redundancy-Based Error Detection; independent recomputation adds a whole second computation, and on disagreement it reconciles rather than auto-corrects, because it cannot yet tell which path is wrong.
Related¶
- Instantiates: Self-Checking Operation — supplies the two-independent-derivations-and-compare machinery for reasoning-level errors.
- Sibling mechanisms: Invariant Checking · Redundancy-Based Error Detection · Constraint Gate Enforcement · Immediate Feedback Routing · Physical Impossibility Design · Safe-Commit Hold · False-Alarm Recalibration
Editorial Notes¶
Form Classification¶
Form family: Assessment, Review & Assurance
Rationale: Independent Recomputation operates as a bounded evaluation of existing evidence or work that produces a finding or disposition because it re-derives the same result by a deliberately different method and compares the two derivations, so a mistake in either path shows up as a disagreement
Independent corroboration: The frozen evidence defines Independent Recomputation as 'Re-derives the same result by a deliberately different method and compares the two derivations, so a mistake in either path shows up as a disagreement', so its operative form is Assessment, Review & Assurance.
Nearest alternative: Experiment, Test & Rehearsal — It assesses an existing result through an independent derivation without exposing an external target to a trial.
Review outcome: Independent reviewer agreement; medium confidence.
Origin Attribution¶
Primary origin: Accounting & Auditing
Origin pattern: Convergent development
Present-day reach: Multi-domain
Rationale: Audit standards define recalculation and independent reperformance as evidence procedures, matching re-derivation and comparison directly; independently implemented software paths and diverse engineering checks are genuine parallel lineages.
Related originating lineages:
- Computer Science & Software Engineering — N-version programming and independently implemented calculations materially extend recomputation into fault-tolerant software assurance.
- Engineering & Design — Independent calculation and diverse redundancy in safety engineering materially shaped the broader cross-check form.
Review resolution: Audit standards define recalculation and independent reperformance as evidence procedures, matching re-derivation and comparison directly; independently implemented software paths and diverse engineering checks are genuine parallel lineages. The retained alternate domains identify documented formative or independently established origins, not downstream applicability alone. domain_reach=multi_domain because the operating pattern has established use in several fields. The entry generalizes an established mechanism without inventing a new cross-domain composite.
Review outcome: Researched adjudication after independent review; high confidence.
Sources consulted:
- https://pcaobus.org/Rulemaking/Docket040/online-demonstration-version.pdf — PCAOB standards text defining recalculation and reperformance as independent audit procedures.
Notes¶
[n1] N-version programming, from software fault tolerance (Avizienis and colleagues): independently developed programs written to the same specification run in parallel and their outputs are compared, on the theory that separate teams are unlikely to make identical mistakes. Independent Recomputation is the general, cross-domain form of the same idea — and it inherits N-version programming's known weakness, correlated error from a shared specification. ↩