Verified clinical analytics · Legacy modernization · Available
Move off legacy without losing the evidence.
Parity is the evidence layer for clinical and legacy analytics. It converts legacy statistical programs and COBOL to R and Python, proves every regenerated output against the original cell for cell, and keeps a hash-verified audit trail behind every number.
Anyone can translate code. The hard part is proving the new code produces the same numbers, and being able to show that to a reviewer. Parity does both, automatically, behind one quality gate that does not negotiate.
| Built for | Biometrics teams, contract research organisations, sponsors and government agencies |
|---|---|
| Converts | Legacy statistical programs and COBOL |
| Targets | R and Python, both, as two independent implementations |
| Acceptance bar | Zero tolerance by default, cell by cell |
| Runs | Fully offline, including air-gapped networks |
| Requires | Python 3.9 or later for the core path |
Migrations don't stall on translation. They stall on proof.
Converting legacy code to R or Python is a solved problem. Demonstrating that the regenerated table matches the original to the last decimal, and showing a reviewer that evidence, is not.
Rounding rules, missing-value ordering and row-lag behaviour differ between platforms. Each produces a plausible wrong answer, never an error.
Double programming and cell-by-cell review is manual, unbudgeted, and consumes exactly the statisticians you cannot spare.
You do not learn the module names. You say what you want, such as "convert this program to R and Python", "analyse this data" or "QC this before we submit", and Parity picks the module, runs it, and reports where the output went. Every module shares one output layout, one audit trail, one environment record and one quality gate.
Legacy statistical programs and COBOL to R and Python, proven cell for cell against the original output.
Profiles any dataset, fixes the analysis plan before the comparison, and runs it reproducibly.
Pins every Python and R package per project, with a Dockerfile and a version ledger.
Systematic literature search with the full PRISMA record, and meta-analysis.
A deterministic quality gate, plus an independent review of the outputs.
Every step, macro, dataset, title and footnote, plus a risk register naming the constructs in this program that behave differently on the new platform, with line numbers.
Input, filters, derivations in order, statistics and options, rounding rule and output layout, written down before any code.
R and Python, both. Two independent implementations agreeing is itself evidence.
Each regenerated table is compared with the original, cell by cell, at zero tolerance by default.
Independent re-derivation from the original source, then the gate. The traceability matrix is closed.
A conversion is only signed off when there are no blocking differences. The gate reads the result, so nothing is signed off on optimism.
Clinical cells are rarely bare numbers. A cell such as "142 (78.5%)" is split into its literal text and its numbers: the text must match exactly and the numbers to a declared tolerance. The default tolerance is zero, and raising it is a decision that is written down and justified, never a quiet setting change.
| Class | What it means | Severity |
|---|---|---|
| Value | A number differs beyond the declared tolerance, or one side is missing | Blocking |
| Text | Wording or layout differs: a label, a footnote, a spanning header | Blocking |
| Structure | Row or column counts differ, or a keyed row cannot be paired | Blocking |
| Format | Same value, different rendering, such as 0.5 against 0.50 | Advisory |
Parity ships a risk register that finds these in your source, by line number, before anyone writes a line of R or Python, together with the correct equivalent for each.
| Construct | What goes wrong on the new platform |
|---|---|
| Rounding | Many legacy platforms round half away from zero; R and Python round half to even, so 2.5 becomes 3 in one and 2 in the other |
| Missing values | Where a missing number sorts below every value, a filter such as x < 5 keeps missing rows; elsewhere it drops them and the population count changes |
| Lagged values | A lag inside a condition is not always the previous row; in R and Python it always is |
| Merging | A legacy merge is not a database join; many-to-many merges behave differently |
| Denominators | Clinical percentages usually use the population count, not the count of non-missing values |
The same problem in COBOL has harder consequences, because the silent differences are money rather than statistics.
Packed decimal fields have no representation error. Ported to a floating-point type, money changes at the cent, on every record, silently.
COBOL discards excess digits rather than rounding, and when it does round it rounds half away from zero, not the way Python and R do.
With PERFORM THRU, every paragraph between the endpoints runs by fall-through. Reordering paragraphs changes the result.
The comparison engine reads fixed-width report output directly, and the run record, tamper evidence, environment lock and quality gate carry over unchanged. For programs whose output is money, Python is the defensible target; this is stated in the documentation, not discovered in a comparison.
Profile first, plan second, and only then analyse. Before anyone runs a model, the profile catches disguised missing codes such as -99 in a score column, categories that differ only by capitals or spaces, site IDs that lost their leading zeros, and two columns that are really the same variable.
Nothing rewrites a previous run. A correction is a new run that references the one it supersedes.
Output fingerprints (SHA-256) are re-checked by the gate. A file edited after the run is detected and blocks release.
Inputs are copied into the run, so it stays verifiable after it is archived.
Paths are stored relative to the run, so an archived folder still verifies after it is moved.
A number is only reproducible if the software stack is recorded. For every project, Parity Lock records every Python and R package and version, the interpreter builds, operating system and code version; writes installable pin lists for both languages and a Dockerfile that rebuilds the whole stack; and keeps an append-only ledger of every environment the project has used. One command verifies a lock and lists every package that has drifted.
PubMed, Europe PMC and ClinicalTrials.gov searched directly; subscription databases ingested from your exports. Records are de-duplicated, trial registry records stay visible so publication bias can be assessed, and exact queries, dates and hit counts are captured for the PRISMA report.
Standard effect measures and estimators, heterogeneity reported with its uncertainty, prediction intervals by default, and small-study tests with their limitations stated. An independent script redoes the analysis so agreement is real evidence.
Parity's statistics are tested against reference results. On the standard BCG vaccine dataset (13 trials, risk ratio, random effects), Parity agrees with the established R package metafor to four decimal places.
| Quantity | Parity | metafor |
|---|---|---|
| Random-effects estimate (log RR) | -0.7145 | -0.7145 |
| Standard error | 0.1798 | 0.1798 |
| 95% confidence interval | -1.0669 to -0.3622 | -1.0669 to -0.3622 |
| tau-squared | 0.3132 | 0.3132 |
| I-squared | 92.22% | 92.22% |
Package and file checksums of the deployed software, a platform record and an environment lock: the machine-readable half of the IQ.
Run the automated verification suite and keep its output and exit status as evidence for the named requirements.
A parallel run: convert outputs you have already signed off, and evidence zero blocking findings at zero tolerance.
The control that matters: no statistic, comparison or verdict is produced by a language model. The model decides what to run and explains the result; a deterministic script produces the number. That boundary is what makes Parity usable for regulated work, and it is testable.
Individual analysts drive it directly. The simplest start.
One auditable archive for a team, with one backup policy.
For CI pipelines and scheduled jobs, the deterministic half on its own.
For regulated work and multi-year reproducibility.
Only the literature module reaches out to the internet, to three public services. Everything else runs fully offline, including on air-gapped networks.
It means the run is intact and self-consistent. Whether the analysis was the right one is a judgement, and a person signs it.
The screening assistant suggests, with reasons, and includes anything uncertain. It does not decide.
Where 21 CFR Part 11 applies, run folders are records to be held inside a validated document system, not a substitute for one.
Maths libraries differ between machines in the last decimals of model fitting. Where that matters, the container is the unit of reproducibility.
A demographics or disposition table you have already delivered, with its output.
R and Python implementations, compared cell by cell at zero tolerance, with the risk register and traceability matrix.
The comparison report, the traceability matrix and the gate verdict: the same artefacts a reviewer would ask for.
Scope the rest against real evidence rather than a proposal.
Every engagement ships with a user guide, technical documentation and a deployment guide that includes the IQ/OQ/PQ mapping. To arrange a pilot or a capability briefing, contact us.
New product ·
Parity converts legacy statistical programs and COBOL to R and Python, and proves every regenerated output against the original cell for cell, with a tamper-evident audit trail behind every number.
Read more →