Stateam Products — Parity
Parity converts legacy statistical and analytics software and COBOL into R and Python — and then proves the result reproduces your original output, cell for cell, before anything ships.
The problem
Translating a program is the easy half, and it is getting easier every quarter. The hard half is convincing a QA function, an auditor or a regulator that the new number is the same number. That is where budgets and timelines actually go.
Legacy statistical languages round half away from zero; R and Python round half to even. A missing value sorts below every number on the old platform and drops out on the new one. Each difference produces a plausible number, not an error message.
Packed-decimal arithmetic is exact and truncates by default. Floating point does not. On a balance, an interest accrual or a benefit calculation, that difference is money.
Double programming and cell-by-cell review consume senior time on every output, every time. It is the largest line in most modernisation budgets and the least automated.
What Parity is
Parity is software, not a services engagement. The deterministic half — the comparison, the statistics, the environment lock and the gate — runs inside your environment against your own programs. The conversion step is agent-assisted, so source you convert is sent to a hosted model; the deployment guide covers running the deterministic half on its own where that is not acceptable.
Legacy statistical and analytics software and COBOL scanned into a risk register that names the constructs needing attention, by line number, plus a traceability matrix with a row for every DATA/PROC step or COBOL paragraph — carried through to the R and Python replacement.
Dataset profiling and analysis that states its assumptions on the page, and surfaces data-quality findings before they reach a conclusion.
Every package version pinned per project, recorded in a lockfile and a Dockerfile, so a result computed today can be recomputed in three years.
Systematic literature search and meta-analysis that reports what it cannot show as clearly as what it can.
Nothing is released until the comparison passes. The gate is a deterministic script with an exit status — it does not negotiate, and it is the same gate for every module.
The acceptance bar
Parity compares your original output against the converted output cell by cell and classifies every difference. Three of the four classes block release. The default tolerance is zero — numbers must match exactly as displayed, after rounding.
Clinical cells are rarely bare numbers. 142 (78.5%) is decomposed into its literal text and its numeric tokens: the text must match exactly, the numbers to a declared tolerance. A non-zero tolerance is written into the run settings and flagged by the gate for justification in your validation summary, so the decision leaves a trace rather than living in someone's shell history.
| Class | What it means | Severity |
|---|---|---|
| VALUE | A number differs beyond tolerance, or one side is missing | Blocking |
| TEXT | Wording or layout differs — a label, a footnote, a header | Blocking |
| STRUCTURE | Row or column counts differ, or a row cannot be paired | Blocking |
| FORMAT | Same value, different rendering — 0.5 against 0.50 | Advisory |
A language model helps write the replacement code and explains its reasoning. Every statistic Parity computes, and every cell-by-cell comparison, comes from deterministic code you can read, run and re-run — never from a model. Reviewer agents will hand-check a value and tell you what they think, which is useful, but their opinion is advice to a human. It is not the comparison, and it is not the number in your report. That boundary is why we built Parity rather than wrapping a chatbot.
Coverage
The comparison engine does not know or care what produced the file it is checking. Adding a language means adding a source scanner and a semantics register — not rebuilding the verification layer.
Evidence
The meta-analysis module reproduces the published metafor reference example — dat.bcg, risk ratio, REML — to four decimal places on the effect estimate, standard error, confidence bounds and τ², and to two on I². Checked against the published values, not against itself.
The same comparison engine was run against fixed-width COBOL report output and caught a one-cent difference in a single cell — a blocking VALUE finding — with an identical-pair control passing cleanly. It is a small fixture, and it ships inside the test suite so you can run it yourself.
Module runs write a dated directory with a manifest and SHA-256 checksums over their inputs and outputs, so a later reader can prove nothing moved. Directories are append-only by convention, and the deployment guide shows how to enforce it with filesystem permissions. The documentation maps Parity's artefacts to the IQ, OQ and PQ questions a validation function will ask.
Straight answers
A vendor that tells you exactly what its product does, and where the judgement stays with you, is a vendor whose other claims you can weigh.
It means the run is intact and self-consistent, and that the converted output matches the original. Whether the original analysis was the right one is a judgement, and a human signs it.
The risk register flags the constructs worth looking at first, by line number, and no static scan catches everything. What actually catches a changed number is the comparison against your original output — which is why Parity does not stop at the scan.
Numerical libraries differ between machines and move the last decimals of model fitting. Where that matters, the pinned container is the unit of reproducibility, not the lockfile alone.
Getting started
Fixed scope, two to three weeks. The fee is credited in full against a licence bought within 90 days. Talk to us and we will scope it against your programme.