Intellectual Frontiers

Theory

Check reproducibility with rules first, a model second and a person last

Most peer reviewers can't spend days rebuilding an analysis. Automation can take that load, but only if it's built in the right order: rules that a program checks without judgment first, a model only for what rules can't answer, and a person last. A higher layer never overrules a lower one.

The order of the layers decides whether the report can be trusted

Claim: hypothesis

Two columns. Review today: reviewers rarely run the code they're given, getting the data is slow, rebuilding a pipeline by hand takes days, and reviews wait. With layered checking: rules check the repository and answer yes, no or cannot tell; a model reads what rules can't and says where it looked; the reviewer gets a report; the reviewer's time goes to the findings.

A rule's answer can be checked: either the release has a DOI or it doesn't. A model's answer can't be checked the same way, and it can be confidently wrong. If the model goes first, every later step inherits errors nobody can see. If rules go first, the model only handles the leftovers, and its answers are labelled as a model's, with the place in the repository it read.

The first layer is the familiar machinery of software: continuous integration, which reruns code on every change; linters, which flag code that breaks style or common-sense rules; and checks of the metadata against a schema. Rules over linked metadata can be written in standard languages such as SHACL, the W3C's language for checking linked data against rules, so nobody has to invent one. The Lovable microsite named logic languages such as Prolog and Datalog for this layer; any of them would do, and the choice should follow the check, not come before it.

The second layer is a model that reads what rules can't: a README that never names its entry point, a variable named one thing in the code and another in the paper, an assumption buried in a comment. The third is a person, who decides what the flags mean.

The result for a reviewer is a short report: which checks passed, which outputs the rerun reached, where it stopped, and what the model flagged and why. The reviewer's time goes to the science instead of the plumbing.

What would show this claim is wrong

  • A model given the whole repository predicts rerun success as well as the rules do, at the same cost, and its errors are no harder to find.
  • Reviewers given the report find no more problems, and take no less time, than reviewers given the repository alone.
  • The rules flag so many harmless issues that reviewers stop reading the report.

Related

Next