Turn DNA into a vector that winds like the real helix.

The numbers

bases per turn found by a small model that was never told the helical period, on four independent libraries (the crystallographic value is 10.534)

10.48 to 10.51

correlation with held-out bendability using the measured twist of each base pair step, against one constant twist

0.529 vs 0.483

correlation with held-out bendability once the local-shape layer is added, against 0.253 for counts of short words

0.600

behind the best trained network, DNAcycP, on every library where it has published scores (0.93, 0.77 and 0.89 against 0.54, 0.50 and 0.60)

0.28 to 0.39

Release 0.1.1Built on Phasor and HoloDb · Twist tables built in · net8.0 and net10.0

• It does not beat the best trained model

  DNAcycP, an approximately 94,000-parameter trained neural network, reaches r = 0.93, 0.77 and 0.89 on the libraries where it has published scores (published figures). The best 22-parameter physical model here reached 0.54, 0.50 and 0.60 on the same libraries, trailing by 0.28 to 0.39.

• More training did not help

  Training the hologram readouts with iterative optimisation left accuracy where it was (r 0.46 to 0.62 across the libraries tested). Running the phasor models for 2.5 times as many steps moved their scores by at most 0.0001.

• The measurement itself has a ceiling

  Loop-seq replicates agree at roughly r = 0.84 to 0.87, so no model can score near 1.0 on it.

• The simplest zero-parameter score is modest

  At r = 0.22 to 0.46 it is well below any trained readout. Its value is that it needs no fitting and matches the known periodicity of the double helix.

• A strand-aware DNA vector for any window of sequence

  One call turns A/C/G/T text into a fixed-width vector whose phase follows the published twist of each base pair step, so order along the helix is in the vector, not just which letters are present.

• Physical features for your own models

  Feed the vectors to any regression or classifier. On a held-out bendability test, a plain linear readout on these vectors beats the same readout on constant-twist vectors and on base-composition counts.

• A queryable window store

  Slide a window along a sequence, store each hologram in HoloDb next to ordinary SQL columns (source, start, sequence), and read them back or compare them by dot product.

• A helix-aware teaching tool

  Show where a sequence winds tighter or looser, how many turns it makes, and why the helix repeats about every 10.5 bases, all computed from published tables.

• Your own shape layer

  Load a minor-groove, propeller-twist, roll and helix-twist pentamer table and add it to the encoding. On the held-out test, the shape layer added measurable accuracy.

• A measure-it-yourself harness

  The encoding takes its numbers from published tables, so any score you derive from it can be compared with an independent laboratory measurement, with no fitted constants hiding in the encoder.

using HoloDb;
using HoloGenome;

var encoder = new GenomeEncoder(new GenomeEncoderOptions { Dim = 512, Twist = OlsonTwist.Instance });
string seq = "ATGCGTACGTTAGCAAAAATTTTTGCGCGATCGATCGTAGCTAGCTAGCA";
double[] h = encoder.Encode(seq);

// How many turns does the helix make along this sequence?
Console.WriteLine($"{h.Length} reals; helix turns: {encoder.HelixPhases(seq)[^1] / (2 * Math.PI):F2}");

// The mean measured twist gives the helical repeat.
double sum = 0;
foreach (char a in "ACGT") foreach (char b in "ACGT") sum += OlsonTwist.Instance.TwistDegrees(a, b);
Console.WriteLine($"{360 / (sum / 16):F4} bases per turn");

// Store the window beside ordinary SQL columns and read it back.
var store = new GenomeWindowStore(new HoloDbService(new HoloDbOptions()));
store.Put([new GenomeWindow(1, "demo", 0, seq, h)]);
Console.WriteLine(store.Get(1)!.Sequence == seq);

512 reals; helix turns: 4.68
10.5340 bases per turn
True

This is the complete program, compiled and run against the published package.

A stretch of DNA becomes one list of phase angles. Each base is a Phasor symbol. As you move along the sequence a carrier phase advances by the measured twist of each pair of neighbouring bases (the published table of Olson et al. 1998), so the vector records how the real double helix winds, not just which letters are present.

An optional second layer adds local shape (minor-groove width, propeller twist, roll, helix twist) from a pentamer table you supply, weighted in as extra signal beside the helical phase. Everything is bound and summed into a single fixed-width vector.

• Each base is a Phasor symbol

  The encoder uses the Phasor codec, so a window is one vector you can bind, sum, store and compare by dot product like any other Phasor value.

• The carrier follows the measured twist

  The phase advances by the measured twist of each pair of neighbouring bases, taken from a published table that is built in. The vector records how the helix winds along the window.

• Shape is optional and yours

  Supply a pentamer table and its minor-groove, propeller-twist, roll and helix-twist values are weighted in beside the helical phase. No third-party shape data ships in the package.

• Nothing in the encoding is invented

  Each number comes from a cited measurement. The one constant twist of 34.3 degrees exists only as the sequence-blind control.

• GenomeEncoder

  Encode(window) gives the fixed-width vector, EncodeWindow(sequence, start, length) encodes a window and uses the bases outside it only as shape context, and HelixPhases(window) returns the cumulative helix angle along the window.

• Twist models

  OlsonTwist is the measured table, with all six step parameters per pair of bases. ConstantTwist is the sequence-blind control. Setting no twist model turns the helix off.

• Local-shape layer

  PentamerShapeTable loads or parses a table you supply, falls back to the reverse complement when a pentamer is missing, and counts the misses. Nothing from a third-party shape table is in the package.

• Window store

  GenomeWindowStore keeps windows in a HoloDb table with ordinary SQL columns beside the hologram: bulk and atomic puts, reads by id, and float32 packing.

• Strict input

  Dna.Normalise accepts A, C, G and T and throws on anything else. Reverse complement and complement helpers are included.

• You need the most accurate bendability predictor. Use DNAcycP, which is trained for exactly that and scores far higher on Loop-seq.
• You need shape tracks for a whole genome. Use a dedicated shape predictor such as DNAshapeR; HoloGenome only reads a table of shape values you load.
• You need alignment, variant calling or annotation. HoloGenome is not an aligner or a caller. It encodes windows of sequence for physical comparison.
• You need clinical or consumer results. It makes no health, disease-risk, drug-response or ancestry claims.

• Sequences must be A, C, G and T. Anything else is rejected, not guessed.
• The hologram is an unnormalised sum, so compare windows of equal length.
• The encoding is strand-specific: a sequence and its reverse complement give different vectors (cosine 0.23 for the example above).
• Stored holograms are float32, exact to about 6e-8 relative error.
• All grading so far uses one kind of measurement (Loop-seq bendability in yeast-derived and random sequence). Nothing is claimed for other organisms, other assays or chromatin in the living cell.
• The graded scores on this page (the linear readout, the zero-parameter helical score and the fitted phasor models) come from a research harness and are not in the shipped package. The package ships the encoder, the twist tables and the window store.
• The shape layer was graded with a pentamer table from the DNAshapeR project. That table is not shipped because its licence does not allow it, so you load your own.
• The Loop-seq data is not redistributed with the package.
• Early-stage package: the public surface may change.

Every public type is documented in the package readme on NuGet. Open the NuGet page.

• Dinucleotide twist and roll: Olson, Gorin, Lu, Hock and Zhurkin, PNAS 95(19):11163 (1998), Table 1, built in.
• Local shape: the DNAshape method (Zhou et al. 2013, NAR) as distributed in DNAshapeR (Chiu et al. 2016), supplied by you at run time.
• Held-out measurements: Basu et al. 2021, Nature 589:462 (Loop-seq).
• Comparison model: DNAcycP (published accuracy figures).

A linear readout trained on 12,472 random-sequence constructs and tested on 82,368 yeast-gene constructs (no shared sequence, forward or reverse complement) scores r = 0.529 with vectors that use the measured twist, against 0.483 with one constant twist (difference 0.046, 95% interval 0.041 to 0.050). Adding the local-shape layer lifts it to 0.600, a further 0.071. A small phasor model that chose its own period, starting from 12 bases, settled at 10.49, 10.51, 10.48 and 10.51 bases per turn on four independent libraries, against the crystallographic 10.534. The best trained network scores higher: the 22-parameter fit trails it by 0.28 to 0.39.

Proprietary. Every package ships as a compiled library. Evaluation and non-commercial development or testing are permitted; commercial, production or revenue-generating use needs a commercial licence from the owner. Read the licence terms.