Homopolymer and Low-Complexity Region Errors: Why Indels in These Regions Are Systematically Miscalled

Zetobit · Bioinformatics Insight Series

Variant Calling · Sequencing Error Models

Homopolymer and Low-Complexity Region Errors: Why Indels in These Regions Are Systematically Miscalled

A run of eight identical bases is not just harder to sequence than a mixed sequence — it is harder in a way that biases the answer. The errors are not random noise; they concentrate, they favor certain lengths, and they survive filtering. Here is where they come from and why they resist correction.

Kanna Nandakumar, PhD Zetobit LLC Reading time ~9 min

Ask a variant caller for the hardest single-nucleotide substitution in the genome and it will usually give you a confident answer. Ask it for the length of a run of ten adenines and it may hedge, waffle, or quietly report the wrong number. Substitutions are a decision among four letters at a fixed position. Indels in repetitive sequence are a decision about how many — and that question is corrupted at every stage of the pipeline, from the polymerase to the aligner to the caller's own likelihood model.

Homopolymers (runs of a single base, e.g. AAAAAAAA) and low-complexity regions (short-period repeats such as ATATATAT or CAGCAGCAG) are where indel accuracy collapses. They are not a rare corner of the genome. Homopolymer runs of length six or more cover a substantial fraction of the human reference, and short tandem repeats number in the hundreds of thousands.^[1] Many are inside or adjacent to coding sequence, and several clinically important genes carry functional repeat tracts. When a pipeline systematically miscalls indels in these regions, it is not making a rare mistake — it is making a predictable one, in predictable places, over and over.

The important word is systematic. Random error averages out with coverage. Systematic error does not: piling on more reads that share the same bias simply makes the wrong answer more confident. Understanding why these errors are systematic — rather than treating them as bad luck to be filtered away — is what separates a pipeline that flags these calls from one that trusts them.

Where the error is born: the polymerase can't count

The trouble starts before any base is called, during the chemistry itself. When a polymerase copies a homopolymer run, it can slip. The nascent and template strands transiently misalign by one unit within the repeat — a phenomenon known as polymerase slippage or slipped-strand mispairing — and the enzyme resumes synthesis with the run one base too long or too short.^[2] The longer the run, the more opportunities to slip, so the error rate climbs with run length rather than staying flat.

Different chemistries express this in different ways. Flow-based and pyrosequencing-style approaches (historically 454, and Ion Torrent) infer homopolymer length from the magnitude of a single incorporation signal: eight bases should give roughly twice the signal of four. But signal does not scale perfectly linearly with length, so distinguishing an 8-mer from a 9-mer means resolving a small difference on a noisy analog measurement — and the uncertainty grows exactly as the run gets longer.^[3] Sequencing-by-synthesis platforms that read one base per cycle avoid the flow-signal problem but still accumulate phasing and slippage artifacts across long runs. Long-read platforms extend the readable repeat length dramatically, but single-molecule reads carry their own indel-dominated error in homopolymers, which is why consensus and polishing steps matter so much there.^[4]

The unifying point: every current chemistry has a length-dependent failure mode in homopolymers, and in all of them the error manifests as an indel — a wrong count — not a substitution. That is the first reason indels in these regions are miscalled more than substitutions anywhere else.

The aligner makes it worse: gaps have nowhere to anchor

Suppose the read is correct and reports nine A's where the reference has ten. The aligner now has to place a one-base deletion somewhere inside a run of identical bases. But every position in the run is indistinguishable, so the gap can be placed at the start, the end, or anywhere in between — all with identical alignment scores. This is the ambiguous-placement problem, and it is intrinsic to repetitive sequence, not a bug in any one tool.

The gap has nowhere to anchor. A single deleted base in a homopolymer run can be placed at any position with an identical alignment score. Left-alignment normalization forces one canonical representation, but only if every tool in the pipeline normalizes the same way — otherwise identical variants are recorded at different coordinates and fail to reconcile.

Ambiguous placement has two downstream consequences. First, the reported position of the indel becomes arbitrary unless it is normalized. The community convention is left-alignment: shift every indel as far left as it can go while preserving the sequence, producing one canonical form.^[5] Tools such as bcftools norm and GATK's LeftAlignAndTrimVariants exist precisely to enforce this. But normalization only helps if it is applied consistently — if a caller emits a right-shifted indel and a downstream annotator expects left-aligned coordinates, the same true variant appears at two positions and silently fails to match a database entry or a prior report.

Second, and more insidiously, the reads themselves may disagree on placement before the caller ever sees them. Reads spanning the run from the left and reads spanning from the right can each carry the gap at a different internal position, so the pileup at any single column looks noisy even when every read agrees the run is one base short. A naive caller reading that column sees conflicting evidence and loses confidence in a call that is actually well-supported.

The caller inherits a corrupted likelihood

Modern callers do not read pileup columns naively; the better ones locally reassemble the region and evaluate candidate haplotypes.^[6] Reassembly helps enormously, because it re-derives a consistent indel representation from the reads rather than trusting their reported alignments. But it does not manufacture information that the chemistry destroyed.

The caller's core operation is to compute the likelihood of the observed reads under each candidate allele — here, competing hypotheses of run length nine, ten, or eleven. Those likelihoods are only as good as the error model behind them. If the model assumes indel errors are rare and length-independent, it will assign artificially sharp likelihoods and produce confident wrong calls in long runs. If it inflates indel-error rates uniformly to compensate, it will lose sensitivity to real short indels in ordinary sequence. Getting this right requires an error model that is explicitly a function of homopolymer length and repeat context — which is why callers designed around such models, and deep-learning callers that learn the context dependence directly from data, outperform naive approaches specifically in these regions.^[7]

The reads carry a wrong count, placed at an ambiguous position, evaluated under an error model that may not know the run is long. Each stage can be individually reasonable and the composite answer still be systematically wrong.

Why more coverage doesn't rescue you

The intuition that deeper sequencing fixes hard calls is correct for random error and false for systematic error. If slippage produces a 9-mer read from a 10-mer template with some characteristic probability, and that probability is a property of the chemistry acting on that sequence, then every read is drawing from the same biased distribution. Averaging a thousand biased draws gives you a precise estimate of the biased value, not the truth. In the worst case — a run long enough that the modal read length is not the true length — more coverage makes the caller more confident in the wrong answer.^[3]

This is the practical crux for anyone reading a VCF. A homopolymer indel with high depth and a high quality score is not automatically trustworthy, because the failure mode here inflates confidence rather than degrading it. The quality score reflects internal consistency of the evidence, and biased evidence is internally consistent. This is exactly why benchmark truth sets carve out low-complexity and segmental-duplication regions and report accuracy separately for them: the genome-wide indel F-score a pipeline advertises is dominated by easy regions and can hide near-random performance inside the hard ones.^[8]

What actually helps

There is no single fix, but there is a disciplined posture. In rough order of leverage:

• Normalize everything, once, canonically. Left-align and trim every indel with a tool like bcftools norm -f before annotation, comparison, or reporting, so that identical variants always share coordinates.^[5] This is the cheapest, highest-return step and it is still routinely skipped.
• Use a caller with an explicit indel-error model or a learned one. Reassembly-based and deep-learning callers are meaningfully better in repetitive context than pileup-threshold methods.^[6,7]
• Stratify your validation. Evaluate against a truth set with region stratification and read the low-complexity numbers separately — never trust a single genome-wide indel metric to describe performance where it matters.^[8]
• Flag, don't silently trust, long-homopolymer indels. Annotate calls by the homopolymer length and repeat context they sit in, and route the long-run calls to orthogonal confirmation rather than reporting them at face value.
• Match the platform to the question. If a clinically important indel sits in a long homopolymer, the chemistry that reads it matters. Long reads with high-quality consensus, or an orthogonal assay, may be the only way to get the count right — no amount of short-read depth will.^[4]

The through-line of this series has been that error is rarely random and rarely uniform. Coverage has a shape; batch effects have a direction; corrections can erase signal. Homopolymer and low-complexity indels are the same lesson in miniature: the error has structure. Once you know the structure — length-dependent at the chemistry, position-ambiguous at the aligner, confidence-inflating at the caller — you stop treating these calls as noise to be filtered and start treating them as a known systematic effect to be modeled, stratified, and confirmed. That shift is the whole difference between a pipeline that reports a number and a pipeline that reports a number you can defend.

---

References

1. Willems T, Gymrek M, Highnam G, et al. The landscape of human STR variation. Genome Research. 2014;24(11):1894–1904. doi:10.1101/gr.177774.114
2. Viguera E, Canceill D, Ehrlich SD. Replication slippage involves DNA polymerase pausing and dissociation. The EMBO Journal. 2001;20(10):2587–2595. doi:10.1093/emboj/20.10.2587
3. Bragg LM, Stone G, Butler MK, Hugenholtz P, Tyson GW. Shining a light on dark sequencing: characterising errors in Ion Torrent PGM data. PLoS Computational Biology. 2013;9(4):e1003031. doi:10.1371/journal.pcbi.1003031
4. Wenger AM, Peluso P, Rowell WJ, et al. Accurate circular consensus long-read sequencing improves variant detection and assembly of a human genome. Nature Biotechnology. 2019;37(10):1155–1162. doi:10.1038/s41587-019-0217-9
5. Tan A, Abecasis GR, Kang HM. Unified representation of genetic variants. Bioinformatics. 2015;31(13):2202–2204. doi:10.1093/bioinformatics/btv112
6. Poplin R, Ruano-Rubio V, DePristo MA, et al. Scaling accurate genetic variant discovery to tens of thousands of samples. bioRxiv. 2018. doi:10.1101/201178
7. Poplin R, Chang PC, Alexander D, et al. A universal SNP and small-indel variant caller using deep neural networks. Nature Biotechnology. 2018;36(10):983–987. doi:10.1038/nbt.4235
8. Krusche P, Trigg L, Boutros PC, et al. Best practices for benchmarking germline small-variant calls in human genomes. Nature Biotechnology. 2019;37(5):555–560. doi:10.1038/s41587-019-0054-x

Zetobit LLC · Bioinformatics Insight Series · Lexington, KY · zetobit.com
Boutique bioinformatics consulting: CAP/CLIA-compliant NGS pipelines, multi-omics analysis, and variant interpretation.