Module 4: Reasoning, Computation, and Engineering Verification

Learning Objectives

  • Separate model reasoning, deterministic computation, code-compliance interpretation, and professional judgment.
  • Delegate arithmetic, symbolic calculation, tabulation, and repeatable numerical work to appropriate deterministic tools when practical.
  • Require units, equations, governing cases, structured outputs, and machine-checkable acceptance criteria.
  • Use independent computational paths, physical reasonableness checks, and sensitivity tests for consequential results.
  • Select model reasoning effort and computational resources proportionately to task complexity rather than maximizing them by default.

Independent Verification

Independent verification is the confirmation of a result using a separate reasoning path, calculation, software implementation, reviewer, or authoritative source rather than relying on the same AI output that produced the original result.

A Safer Calculation Sequence

For engineering calculations, require a reviewable order:

  1. Restate verified inputs with units and provenance.
  2. Identify missing or contradictory data.
  3. State the governing equation or method.
  4. Explain applicability conditions.
  5. Perform symbolic manipulation before substitution where useful.
  6. Substitute values with explicit units.
  7. Report reproducible intermediate results.
  8. Identify the governing case.
  9. Perform dimensional, sign, magnitude, and boundary checks.
  10. State limitations, stop conditions, and required independent checks.
Calculation Verification Workflow

A safer sequence for AI-assisted engineering calculations.

The workflow separates the primary calculation from an independent check so agreement is earned rather than assumed.

Calculation Verification WorkflowA safer sequence for AI-assisted engineering calculations.. Verify inputs, units, and assumptions → Primary calculation path; Verify inputs, units, and assumptions → Independent check or alternate method; Primary calculation path → Results agree within justified tolerance?; Independent check or alternate method → Results agree within justified tolerance?; Results agree within justified tolerance? — Yes → Accept reviewed result; Results agree within justified tolerance? — No → Investigate arithmetic, units, signs, method, or assumptions; Investigate arithmetic, units, signs, method, or assumptions → Verify inputs, units, and assumptions

Verify inputs, units, and assumptions → Primary calculation path; Verify inputs, units, and assumptions → Independent check or alternate method; Primary calculation path → Results agree within justified tolerance?; Independent check or alternate method → Results agree within justified tolerance?; Results agree within justified tolerance? — Yes → Accept reviewed result; Results agree within justified tolerance? — No → Investigate arithmetic, units, signs, method, or assumptions; Investigate arithmetic, units, signs, method, or assumptions → Verify inputs, units, and assumptions

  • Verify inputs, units, and assumptions: terminator
  • Primary calculation path: process
  • Independent check or alternate method: process
  • Results agree within justified tolerance?: decision
  • Investigate arithmetic, units, signs, method, or assumptions: process
  • Accept reviewed result: terminator

Dimensional, Magnitude, Sign, and Boundary Checks

A robust AI-assisted calculation should include:

  • Dimensional consistency: equation terms have compatible dimensions.
  • Order of magnitude: results are plausible for the project scale.
  • Sign and coordinate consistency: forces, moments, slopes, flows, and directions follow the stated convention.
  • Boundary behavior: simplified or limiting cases respond physically as expected.

These checks are useful precisely because polished mathematical formatting can conceal a wrong result.

Engineering Calculation Assurance Stack

Each layer supports confidence in the final result.

Use the stack from inputs upward; a correct-looking final number is weak evidence if lower layers were not checked.

1
Verified inputs and units
2
Applicable equations or method
3
Intermediate arithmetic
4
Physical reasonableness checks
5
Independent verification

Prompt Pattern for Calculation Review

Review the supplied calculation without assuming missing values.
1. Tabulate all inputs with units and source labels.
2. State the governing equation and applicability conditions.
3. Recompute every intermediate value.
4. Check dimensions, units, signs, and coordinate conventions.
5. Compare the recomputed result with the submitted result.
6. Identify the first point of divergence, if any.
7. Challenge the result using magnitude and limiting-case checks.
8. Do not claim code compliance unless the governing provision is supplied or verified.
Four Independent Sanity Checks

A compact map of common engineering calculation checks.

These checks catch different failure classes and should not be treated as substitutes for one another.

Dimensional consistency
Order of magnitude
Sign and direction
Boundary or limiting behavior

Separate Computation from Compliance

A correct arithmetic result is not automatically a compliant design. Code applicability, load combinations, reduction factors, detailing provisions, serviceability limits, durability requirements, and project-specific criteria may govern independently of the numerical calculation being checked.

Common AI Calculation Failure Modes

Watch for unit conversion errors, silent rounding, wrong sign conventions, formula substitution from the wrong discipline, fabricated coefficients, omitted load cases, inconsistent coordinate systems, repeated use of the same faulty assumption in both verification paths, and numerical answers produced from missing inputs.

Two-Path and Adversarial Verification

For higher-consequence work, use genuinely different paths such as:

  • hand calculation versus spreadsheet;
  • spreadsheet versus Python script;
  • closed-form equation versus numerical model;
  • independent engineer calculation versus AI-assisted calculation;
  • tabulated standard value versus computed estimate.

Then use an adversarial review that actively tries to falsify the result. Agreement between two paths does not prove correctness if both paths inherit the same incorrect input or assumption.

Primary Path Versus Independent Path

Independent verification is strongest when the second method does not simply repeat the same reasoning.

A second path should differ enough from the first to expose shared mistakes.

Primary path
  • Detailed formula or script
  • Full project input set
  • Production assumptions
Independent path
  • Simplified hand check
  • Alternate equation or software
  • Known limiting case
Calculation Failure-Resolution Loop

Failed checks trigger investigation, correction, and retesting.

When checks fail, return to the earliest uncertain layer rather than forcing the workflow to produce a final answer.

Verified calculation
Compute
Cross-check
Locate discrepancy
Correct source or method
Recompute and approve
↺ repeat when checks fail

Worked Use Cases and Reusable Prompts

The companion Worked Examples contains reusable prompts for arithmetic audits, dimensional checks, governing-case comparison, sensitivity analysis, second computational paths, assumption extraction, adversarial falsification, and calculation audit records.

Prefer Deterministic Tools for Deterministic Work

A language model should not be the only calculator when the task can be expressed reliably in code, a spreadsheet, a solver, or validated engineering software. Use the model to understand the problem, construct or inspect the method, identify missing evidence, and interpret results; use deterministic tools to execute repeatable arithmetic and transformations; then independently verify the governing result.

This division makes numerical work easier to reproduce, test, and audit.

Use Structured Calculation Outputs

For automated review, request machine-checkable calculation records such as:

case_id | input_revision | equation_id | value | unit | check_status | evidence

Structured fields reduce ambiguity, support regression tests, and make it easier to detect missing cases, unit mismatches, duplicated records, or unsupported results. Narrative explanation can accompany the record but should not be the only representation of critical numerical state.

Reasoning Effort Is an Operational Control

Current reasoning models expose different capability, latency, and cost trade-offs. Use stronger reasoning or higher effort when the task genuinely requires difficult planning, synthesis, or ambiguity resolution. Do not spend frontier-level reasoning on arithmetic that a deterministic function can perform more safely. Measure whether additional reasoning improves the evaluation set before making it the default.

Verification Should Challenge the Governing Result

Independent checking should include more than recomputing the same formula. Where appropriate, test limiting behavior, dimensional consistency, alternate formulations, sensitivity to uncertain inputs, order of magnitude, sign conventions, conservation laws, and whether the reported governing case changes under plausible perturbations.

Key Takeaways
  • AI should expose the calculation path, not only the answer.
  • Dimensional, magnitude, sign, and boundary checks are essential engineering controls.
  • Arithmetic correctness and code compliance are different questions.
  • Independent verification must use a genuinely separate path and verify assumptions as well as numbers.
  • Missing data should stop or qualify a calculation rather than trigger silent guessing.

References