Deterministic Computation How MetTutor Puts Validated Numbers Behind AI

Deterministic Computation-How MetTutor Puts Validated Numbers Behind AI

Picture an assessor at your bench. She points at an expanded uncertainty on one of your certificates and asks a simple question: “Show me how you got this number.”

If the answer is “our spreadsheet” or “our calculation software,” you show the validation record behind it. Both are validated before use, and both give the same result for the same inputs every time.

If the answer is “I asked an AI,” you have a problem. It’s not that the number is necessarily wrong. It’s that nobody, including the AI, can show you how it was produced, or promise it would come out the same way twice.

AI is arriving in calibration labs whether we plan for it or not. Technicians use chat assistants to check budgets. Students use them to study for the ASQ CCT exam. Quality managers use them to draft procedures. That’s mostly a good thing. But metrology has one rule that generative AI quietly breaks, and every lab should understand it before AI gets anywhere near a reported value. The fix has a name: deterministic computation.

The 1.2 % that nobody would have caught

Early in the development of MetTutor, an AI learning assistant for metrology, the development team asked the language model to work a Welch-Satterthwaite evaluation itself. It reported a combined standard uncertainty of 0.002788 V. The correct, hand-verified value was 0.002822 V.

That’s a 1.2 % error. It looked completely reasonable. The explanation around it was fluent and confident. Nothing on the screen suggested anything was wrong. If the team hadn’t checked it by hand, nobody would have questioned it.

That is the real risk. Not the obviously absurd answer, which anyone would catch, but the plausible one that slides through. In most fields, 1.2 % is a rounding conversation. In metrology, an uncertainty that’s wrong in its third significant figure can move a reading across a guard band and turn a pass into a fail.

Here’s why it happens. A large language model doesn’t calculate. It predicts the next piece of text from patterns learned in training. It has no arithmetic unit. Ask it the same question twice and you can get two different numbers, even at its most repeatable settings, because the servers that run these models add floating-point numbers in a different order depending on load. NIST has a name for the failure mode: confabulation, confidently stated but wrong content, sometimes with a convincing worked solution attached.

Now line that up against what our quality system assumes:

• ISO/IEC 17025 clause 7.11 requires calculation software to be validated before use. You can’t validate something whose output changes from run to run.
• The GUM is a defined procedure. Two competent evaluators with the same budget must get the same combined uncertainty.
• Decision rules must give one conformity statement per measurement. “It depends which run you got” is not a decision rule.

“Mostly right” doesn’t pass an assessment. Reproducible and traceable does.

Generative AI for learning, deterministic computation for numbers

The answer isn’t to ban AI from the lab. That would throw away the most useful thing it does.

Think about the best senior metrologist you ever worked with. They could explain why a coverage factor grows when a Type A estimate has few degrees of freedom. They could tell you what a guard band actually buys you in false-accept risk. They answered the follow-up question, and the one after that, without making you feel slow. But when it came time to report a number, they ran it through a validated method, not off the top of their head.

That senior metrologist is the model for AI in the lab, and it comes down to two different kinds of computing:

• Generative AI creates new content from patterns it learned. It’s probabilistic by design, which is exactly why it’s good at language: explaining a concept three different ways until one clicks, answering the follow-up question, coaching someone through a CCT practice problem at 2 a.m. That’s learning, and it’s where generative AI shines.
• Deterministic computation follows a fixed, explicit algorithm: the same input gives the same output, every time, on every device. It can’t write an explanation, but it can be tested case by case and validated, which is what ISO/IEC 17025 and the GUM assume about every reported number.

Put those together and you get one architectural rule, set out in the Metrology Institute white paper Deterministic Computation in AI-Assisted Metrology: deterministic computation produces every number, and generative AI only explains it. It’s not a compromise between two technologies. It’s a division of labor that plays to the strengths of each.

How MetTutor implements deterministic computation

MetTutor’s eight calculators are built on that rule. Here’s what deterministic computation looks like inside each one:

1. A user guided form. You enter values in fixed fields, so every request arrives in the same structure, no matter how you’d have phrased a question.
2. A strict parser. Code reads each field as an exact quantity with its unit. Anything ambiguous, such as a comma decimal or a missing unit, is refused, not guessed.
3. Exact arithmetic. Values are held as exact fractions built from the digits you typed, so 0.1 + 0.2 is exactly 0.3, not the computer’s 0.30000000000000004. Only quantities that can’t be exact, such as factors involving π, use floating point, and those are checked against independent high-precision references.
4. One presentation function. A single function writes every number on the card and in the PDF, Word and spreadsheet exports, so they can never disagree.
5. Generative AI last. Only then does the language model see the results, marked as authoritative. It writes the explanation and teaches around them, and it is not allowed to recompute, re-round or dispute a single value.

The result: enter the same form twice, on any device, and you get the same card, digit for digit. The explanation may be worded differently each time, because that part is generative. The numbers never change, because that part is deterministic.

Two behaviors show the difference between deterministic computation and a generative chat assistant better than any diagram.

It refuses rather than guesses. In the Type B Uncertainty Estimator, enter a manufacturer specification with “Percent of reading: 0” and nothing else. A chat assistant will happily produce an uncertainty anyway. MetTutor returns a refusal: Cannot compute u — invalid Specification terms. Every specification term entered is zero. At least one non-zero term is required. It quotes what you entered and tells you how to fix it. A wrong number that looks right is exactly what the system is built to prevent.

It notices what doesn’t add up. In the Decision Rules & Guard Band Calculator, take a 10 V nominal with a ±0.05 V tolerance, a reading of 10.01 V, and a certificate stating U = 0.02 V at k = 2 with a 99 % level of confidence, judged under ISO 14253-1. The verdict is computed exactly: CONFORMING, guard band 0.017 V, acceptance limits 9.967 V to 10.033 V. But the card also carries a warning:

The coverage factor k = 2 is smaller than the 99% level allows (k ≥ 2.576 even at infinite degrees of freedom). Check the certificate; the guard band uses U as entered.

That’s the kind of inconsistency a sharp reviewer catches on a certificate and a tired one misses. The calculator doesn’t change your numbers or overrule you. It flags the conflict, explains why it matters, and leaves the judgment where it belongs, with the metrologist.

The display rules are deliberately conservative, too. A shown value never flatters the result: an uncertainty used as a denominator is rounded up, a test uncertainty ratio is truncated so 3.996 shows as 3.99:1 rather than 4.00:1, and a tolerance derived from a percentage is rounded down. Nobody reads a card and walks away thinking they met 4:1 when they didn’t.

“Validated” should come with numbers

Every vendor says their software is accurate. In metrology we’re trained to ask for the evidence, so here it is.

This is where deterministic computation pays off. Because each input has exactly one correct output, a deterministic calculator can be tested case by case, and a single mismatch is a finding. A generative model can only be sampled, and a passing sample says nothing about the next run. Each MetTutor calculator was compared against an independent reference implementation, written from the standards in exact arithmetic and sharing no code with the production software:

• 68,000 random test cases across all eight calculators, every displayed value compared, zero mismatches.
• Published known answers reproduced to their printed precision, including the GUM’s own gauge-block example (H.1), UKAS M3003 and LAB 48 examples, Z540.3 Handbook guard-band tables, and the NIST SP 811 conversion factors.
• Boundary and refusal cases, including 1,054 inputs that must be refused, all refused.
• A permanent suite of 3,987 automated tests that runs before every change.
• Live tests entered in the production app and exported, with card, PDF and explanation checked against expected values.

Zero failures in 68,000 independent cases puts the failure rate below about 4.4 in 100,000 per case at 95 % confidence, and the cases were deliberately spread across every unit domain, decision band and branch of the logic.

Just as important, the testing finds real problems. It caught a rule that treated any entered degrees of freedom of 1,000 or more as infinite, which changed the coverage factor and expanded uncertainty in 30 of 6,000 random budgets. It caught a percentage tolerance being displayed rounded to nearest, so the shown value could sit a hair above the true one. Both were fixed, re-validated, and documented. When display changes are made, every earlier validation input, all 69,667 of them, is re-run before and after and compared field by field.

That’s what “validated” should mean: not a claim, but a record you can audit. The validation results are available on request.

Who MetTutor is for

The MetTutor team built the platform because our field has a workforce problem. Experienced metrologists are retiring faster than new ones are being trained, and the knowledge that walks out the door is exactly the judgment that AI can help teach, provided the numbers underneath are trustworthy.

• Calibration technicians get a tutor that explains the why behind every result, and calculators they can check their hand work against.
• ASQ CCT candidates get generative AI tutoring grounded in the body of knowledge, with every worked number produced by deterministic computation, so no one learns from a wrong answer.
• Instructors and AAS programs get consistent, reproducible examples. Every student who enters the same values sees the same card.
• Quality and lab managers get calculators whose validation is documented, whose display rules are conservative, and whose behavior can be explained to an assessor.

The calculators are organized by plan. The Explorer plan includes the SI Unit Converter, TAR Calculator and TUR Calculator (Simplified). Student adds the Type B Uncertainty Estimator. Professional adds the advanced tools: the GUM Uncertainty Budget Calculator, Welch-Satterthwaite Effective Degrees of Freedom, the full Z540.3 TUR and risk calculator, and the Decision Rules & Guard Band Calculator. Each calculator has its own instruction guide explaining its inputs, method, display rules and refusals, and team and organization plans are available for labs and training programs.

Five questions to ask any AI tool before it touches your measurement data

Whether you use MetTutor or not, these questions will tell you quickly whether an AI tool belongs near a reported value:

1. Where do the numbers come from? If the language model produces them, they’re unvalidated.
2. Will it give the same answer tomorrow? Run the same input twice, and again after a model update.
3. What happens with bad input? A good tool refuses and tells you why; a risky one gives you a number anyway.
4. Can I see the validation evidence? Ask for case counts, known answers and change control, as ISO/IEC 17025 7.11 expects.
5. Do the display rules ever flatter the result? A 3.996:1 displayed as 4.00:1 is a finding waiting to happen.

The bottom line

Generative AI can make metrology easier to learn, easier to teach and easier to apply. The MetTutor team believes that strongly enough to have built a platform around it. But a measurement result has to be reproducible, traceable and defensible to an assessor, and only deterministic computation meets that bar. Generated numbers don’t.

So let generative AI do what it does brilliantly: explain, teach and answer the next question. Let deterministic computation do what our standards require: produce validated numbers.

So go back to that assessor at your bench: “Show me how you got this number.” With deterministic computation, the answer is simple. Here are the inputs exactly as entered. Here is the method from the standard that produced the result. Here is the validation record behind that method. And here is the same number again, digit for digit, when we run it in front of you. Generative AI helped your technician understand the result; deterministic computation is how you got it.