SalutefaceAAC/synthidbio-sequence-pilot

SynthID Bio sequence scoring — public-key conformance vectors and null model

A small, fully verifiable reproducibility package for the public-key sequence scoring algorithm used by SynthID Bio, plus a closed-form null model for calibrating detection thresholds.

Not affiliated with Google or Google DeepMind. Not peer reviewed. Not an accepted upstream contribution. It is an auditable starting point, published for scrutiny. Built on upstream material released under Apache-2.0 (code) and CC-BY-4.0 (materials) — see NOTICE.

Read this first: what the scores in this dataset mean

The public_key_mean_g column is computed with the public keys 0..24. The published g-values in the original FASTA headers were produced with secret laboratory keys that are not in any public release.

The consequence is the single most important fact about this dataset:

Public-key scores carry no watermark detection signal. Watermarked and unwatermarked sequences both score near 0.5, and in this sample the watermarked sequences do not score higher than the unwatermarked ones.

That is the expected and correct result, not a negative finding about SynthID Bio. A watermark keyed to a secret is supposed to be invisible without the key. Anyone who reads these numbers as a detector evaluation has misread them. What they are good for is implementation conformance and null calibration, which is what this package is for.

What is actually in here

Sequences	10 (2 input backbones + 8 ProteinMPNN designs)
Backbones	5L33 (106 aa), 6MRR (68 aa)
Conformance vectors	8, each reproducing to 0.0 absolute difference
Independent implementations agreeing	3 (browser JS, upstream PyTorch, the Python scorer here)
Tests	56, dependency-free, python scorer/test_scorer.py

This is a small dataset. It is deliberately scoped to what can be verified end to end from the files in this repository. The much larger pilot cohort it came from is not included — see docs/NOT-INCLUDED.md, which lists exactly what is missing and how to regenerate it.

Files

data/
  sequences.csv                     10 sequences, scored, with null statistics
  scorer_test_vectors.json          conformance vectors (the contract)
  null_model_reference.json         closed-form null statistics per sequence
  pilot_provenance.json             exact seeds, args, versions, upstream commit
  pilot_official_verification.json  upstream cross-check summary
  reference_verification.json       per-example published values
  source_checksums.json             sha256 of every original input
  raw_fasta/                        the four original .fa files, unmodified
scorer/
  synthidbio_sequence_scorer.py     dependency-free reference implementation + CLI
  test_scorer.py                    56 checks
  scoring.js                        the browser implementation (Apache-2.0 derivative)
analysis/
  null_model.py                     closed-form null model + per-sequence thresholds
repro/
  reproduce_pilot.sh                regenerate the full pilot from pinned inputs
docs/
  FINDINGS.md  LIMITATIONS.md  NOT-INCLUDED.md  NULL-MODEL.md

Quick start

# Verify this machine reproduces every published score bit-for-bit
python scorer/test_scorer.py

# Score your own sequences
python scorer/synthidbio_sequence_scorer.py my_sequences.fa

# Per-sequence null thresholds
python analysis/null_model.py my_sequences.fa

No dependencies beyond the Python 3.10+ standard library.

The algorithm, precisely

A score is the mean of binary g-values over all (window, key) pairs:

• The alphabet is ACDEFGHIKLMNPQRSTVWYX; a residue's index in that string is its token id.
• The hash IV is SHA-256 over the keys packed as little-endian int64, read back big-endian and reduced mod 2**63 - 1. For keys 0..24 this is 7075662018555685257, which test_scorer.py derives independently.
• Each 4-residue window folds its tokens into the IV with state = int64((state + value) * 6364136223846793005 + 1).
• Per key: accumulate the key, then 12 rounds of accumulate(state, 1) >> 5, then take bit 30. Arithmetic shifts and signed 64-bit wraparound are load-bearing — this is why the port reproduces exactly.
• The first three residues cannot end a window, so windows = length - 3 and every score is an exact rational k / (windows * 25).

The technical contribution: a closed-form null model

The pilot's open problem was calibration. Two 95th-percentile thresholds derived from small cohorts produced held-out negative flag rates of 12.5% and 4.7% — a spread far too wide for a well-determined threshold.

Calibrating a threshold from a cohort conflates cohort sampling noise with each sequence's own score variance. The second part has a closed form and needs no cohort at all:

score = 1/(W*K) * sum over windows and keys of b[w,k]
Var    = 1/4 * (sum_i m_i^2) / (W^2 * K)
SE     = 0.5 * sqrt(R / (W*K)),   R = (sum_i m_i^2) / W

where W = length - 3, K = 25, and m_i are the multiplicities of the distinct 4-residue contexts.

R is a repeat inflation factor, and it exists because of a property of the construction that a naive standard error ignores:

Identical 4-residue contexts produce identical bits. A repeated 4-mer is not an independent draw.

So the naive 0.5/sqrt(W*K) understates the standard error for any sequence with repeated contexts, and W*K/R is the effective number of independent bits. R = 1 when every context is distinct; a poly-A sequence collapses to R = W and just 25 independent bits regardless of its length. Both bounds are asserted in the test suite.

The practical upshot: use a per-sequence threshold 0.5 + z * SE rather than one shared constant. For the two backbones here that is 0.5162 (5L33, 103 windows) and 0.5204 (6MRR, 65 windows) at the 95th percentile — they are not the same number, and treating them as one is a direct source of the instability the pilot observed.

Full derivation, assumptions and honest caveats: docs/NULL-MODEL.md.

What the null model says about this sample

All 10 sequences sit within ±2.1 standard errors of 0.5. The largest deviation is 6MRR-baseline-2 at z = +2.06, two-sided p = 0.039 uncorrected — which across 10 comparisons is not significant (Bonferroni-adjusted p ≈ 0.39). Separately, reference_verification.json records that a batch of all 810 released sequences spans 0.4697 to 0.5262, a tight band around 0.5.

Both observations are consistent with public-key scores containing no detection signal, exactly as the construction predicts.

Verification chain

Three things are independently checkable from this repository alone:

1. Hash IV — derived from first principles by test_scorer.py, not copied.
2. Eight scores — reproduce at 0.0 absolute difference against the values recorded by the browser implementation.
3. Upstream agreement — pilot_official_verification.json records a maximum absolute error of 0.0 against the unmodified upstream SynthIDLogitsProcessor.compute_g_values across 5,596 records, and reference_verification.json records 4.996e-16 for an independent Python cross-check over 810 sequences.

Item 3 is a recorded claim from the original run, not something this repository re-executes; its inputs are not included. Items 1 and 2 you can check yourself in under a second. The two native backbone rows (5L33-native, 6MRR-native) have no published reference value and were scored here for the first time.

Intended use

Provenance and detection research: verifying a scorer implementation, calibrating null thresholds, and reproducing a published pilot. The upstream project is a biosecurity provenance tool, and this package is aimed at the defensive side of it — establishing what a detector's null behaviour is.

Out of scope: this dataset does not support claims about watermark evasion, and it contains no information that would help strip a watermark. The scores here are keyless, so they say nothing about keyed detection either way.

Limitations

The short version — the full version is docs/LIMITATIONS.md:

• Public-key scores are not laboratory-key scores and carry no detection signal.
• No biological property was measured. No binding, folding, expression or function, before or after any edit. Sequence-context retention is not function retention.
• 10 sequences and 2 backbones is far too small for distributional claims.
• The 12.5% / 4.7% flag rates are finite-cohort numbers from data not in this package. They expose calibration uncertainty; they are not detector performance figures.
• The null model treats distinct contexts as independent draws. The hash is not a random oracle, so that is an approximation for the across-context term. The repeat correction itself is exact by construction.
• This package does not implement the structure-based detector, does not verify arbitrary protein provenance, does not reproduce secret keys, and cannot show that an unmarked protein is natural.

Citation

@misc{synthidbio_sequence_pilot_2026,
  title  = {SynthID Bio sequence scoring: public-key conformance vectors and null model},
  year   = {2026},
  note   = {Independent reproducibility package. Not affiliated with Google DeepMind.},
  url    = {https://deepmind.google/blog/introducing-synthid-bio/}
}

Upstream work this is built on:

• Blog: https://deepmind.google/blog/introducing-synthid-bio/
• Paper: https://www.nature.com/articles/s41586-026-10965-y
• Code: https://github.com/google-deepmind/synthidbio (commit acd75747b14c7f4c3c65ad1e6af1483aeba47614)

Feedback wanted

Specifically on: cohort separation and held-out backbone splits, threat-model definition, whether the across-context independence assumption in the null model holds under the real hash, and what a non-hazardous function assay for the robustness axis should look like.