Introduction

Every living cell is driven by proteins, and proteins are chains of amino acids called peptides. To understand disease, drug action, or cell behaviour, scientists need to know which peptides are present in a sample — and in what amounts. The tool they reach for is a mass spectrometer.

The instrument works by fragmentation. A peptide is ionized, selected, and then deliberately broken apart inside a collision chamber. The resulting fragments — called b-ions and y-ions — are measured by the mass their charged pieces carry. The output is a spectrum: a list of peaks, each at a mass-to-charge ratio that corresponds to a particular fragment.

The puzzle is now a matching problem. Given the observed spectrum, which amino-acid sequence would produce exactly those fragment masses? The answer is not obvious: twenty amino acids can be chained in astronomically many ways, and real spectra are noisy and incomplete. The field has spent decades turning this needle-in-a-haystack search into a tractable computation — and it is still an open engineering challenge.

Match the Spectrum

Below is a simulated tandem-MS experiment. An unknown peptide was fragmented; the observed spectrum shows the resulting peaks (mass values in Daltons). Four candidate sequences are listed. For each candidate the demo computes the theoretical b- and y-ions and counts how many match the observed peaks within a tolerance window.

<p class="hint">A peptide was fragmented in a mass spectrometer. The blue peaks are the <b>observed spectrum</b>. Click <b>Show ions</b> on each candidate to see its theoretical b-ions (green) and y-ions (red) overlaid. Solid lines match an observed peak; dashed lines do not. The candidate with the most matches wins.</p>
<div class="spectrum-wrap">
  <div class="spectrum-label">Observed spectrum</div>
  <canvas id="spectrum" width="560" height="120"></canvas>
</div>
<div class="candidates" id="candidates"></div>
<div class="status" id="status"></div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .6rem; line-height: 1.45; }
.spectrum-wrap { margin-bottom: .5rem; }
.spectrum-label { font-size: .78rem; color: #666; margin-bottom: .2rem; font-weight: 600; text-transform: uppercase; letter-spacing: .04em; }
canvas { display: block; width: 100%; border: 1px solid #cdd9e3; border-radius: 6px; background: #f8fafc; }
.candidates { display: flex; flex-direction: column; gap: .45rem; }
.cand-row { display: flex; align-items: center; gap: .5rem; flex-wrap: wrap; padding: .4rem .6rem; background: #f1f5f9; border-radius: 8px; border: 1.5px solid transparent; transition: border-color .15s; }
.cand-row.selected { border-color: #1d3557; background: #e8eef3; }
.cand-seq { font: 700 15px ui-monospace, monospace; color: #1d3557; min-width: 90px; }
.cand-score { font-size: .82rem; color: #555; flex: 1; }
.cand-score b { color: #0a7d33; }
button.show-btn { font: 600 13px system-ui, sans-serif; padding: .3rem .7rem; border: 1px solid #1d3557; background: #1d3557; color: #fff; border-radius: 6px; cursor: pointer; white-space: nowrap; }
button.show-btn.active { background: #c92f3c; border-color: #c92f3c; }
.status { font-size: .95rem; font-weight: 600; margin-top: .5rem; min-height: 1.3em; color: #0a7d33; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Mass-spec peptide identification: match observed fragment-ion peaks to the theoretical
// Monoisotopic residue masses (Da) for the 20 standard amino acids.
const AA_MASS = {
  G:57.02, A:71.04, V:99.07, L:113.08, I:113.08,
  P:97.05, F:147.07, W:186.08, M:131.04, S:87.03,
  T:101.05, C:103.01, Y:163.06, H:137.06, D:115.03,
  E:129.04, N:114.04, Q:128.06, K:128.09, R:156.10
};
const H2O = 18.011;
const PROTON = 1.00728;
const TOL = 0.5; // Da matching tolerance window (instrument resolution)

// Simulated observed peaks — the exact theoretical b-ions and y-ions of AGVLM (the correct answer).
const OBS = [
  72.05, 129.07, 228.14, 341.22,
  150.06, 263.14, 362.21, 419.23
];

// Four candidate peptide sequences to score against the observed spectrum.
const CANDIDATES = [
  { seq: 'AGVLM', label: 'AGVLM' },
  { seq: 'AGVMS', label: 'AGVMS' },
  { seq: 'AGVLP', label: 'AGVLP' },
  { seq: 'MGVLA', label: 'MGVLA' }
];

// Compute theoretical b-ions and y-ions for a sequence.
function theoreticalIons(seq) {
  const n = seq.length;
  const ions = [];
  let bMass = PROTON;
  for (let i = 0; i < n - 1; i++) {
    bMass += AA_MASS[seq[i]];
    ions.push({ mz: parseFloat(bMass.toFixed(2)), type: 'b', pos: i + 1 });
  }
  let yMass = H2O + PROTON;
  for (let i = n - 1; i > 0; i--) {
    yMass += AA_MASS[seq[i]];
    ions.push({ mz: parseFloat(yMass.toFixed(2)), type: 'y', pos: n - i });
  }
  return ions;
}

// Count how many theoretical ions fall within TOL Da of an observed peak.
function score(ions) {
  return ions.filter(ion => OBS.some(o => Math.abs(o - ion.mz) <= TOL)).length;
}

const scored = CANDIDATES.map(c => {
  const ions = theoreticalIons(c.seq);
  return { ...c, ions, sc: score(ions) };
}).sort((a, b) => b.sc - a.sc);

// Render the spectrum canvas: observed peaks in dark blue, overlaid ions color-coded.
function drawSpectrum(highlightIons) {
  const canvas = document.getElementById('spectrum');
  const ctx = canvas.getContext('2d');
  const W = canvas.width, H = canvas.height;
  ctx.clearRect(0, 0, W, H);
  const maxMz = 460, minMz = 50;
  const pad = { l: 36, r: 10, t: 10, b: 22 };
  const plotW = W - pad.l - pad.r;
  const plotH = H - pad.t - pad.b;

  // Draw axes and m/z tick labels.
  ctx.strokeStyle = '#bbb'; ctx.lineWidth = 1;
  ctx.beginPath(); ctx.moveTo(pad.l, pad.t); ctx.lineTo(pad.l, pad.t + plotH);
  ctx.lineTo(pad.l + plotW, pad.t + plotH); ctx.stroke();

  ctx.fillStyle = '#888'; ctx.font = '9px system-ui';
  for (let mz = 100; mz <= maxMz; mz += 100) {
    const x = pad.l + ((mz - minMz) / (maxMz - minMz)) * plotW;
    ctx.beginPath(); ctx.moveTo(x, pad.t + plotH); ctx.lineTo(x, pad.t + plotH + 3); ctx.stroke();
    ctx.textAlign = 'center'; ctx.fillText(mz, x, pad.t + plotH + 13);
  }
  ctx.textAlign = 'left'; ctx.fillText('m/z', pad.l + plotW - 14, pad.t + plotH + 13);

  // Draw the observed peaks as solid dark-blue sticks.
  OBS.forEach(mz => {
    const x = pad.l + ((mz - minMz) / (maxMz - minMz)) * plotW;
    ctx.strokeStyle = '#1d3557'; ctx.lineWidth = 2;
    ctx.beginPath(); ctx.moveTo(x, pad.t + plotH); ctx.lineTo(x, pad.t + 12); ctx.stroke();
  });

  if (!highlightIons) return;

  // Draw theoretical ion positions; solid if matched, dashed if unmatched.
  highlightIons.forEach(ion => {
    const x = pad.l + ((ion.mz - minMz) / (maxMz - minMz)) * plotW;
    const matched = OBS.some(o => Math.abs(o - ion.mz) <= TOL);
    ctx.strokeStyle = ion.type === 'b'
      ? (matched ? '#0a7d33' : '#6abf7d')
      : (matched ? '#c92f3c' : '#e08080');
    ctx.lineWidth = matched ? 2.5 : 1.2;
    ctx.setLineDash(matched ? [] : [3, 3]);
    ctx.beginPath(); ctx.moveTo(x, pad.t + plotH - 2); ctx.lineTo(x, pad.t + 30); ctx.stroke();
    ctx.setLineDash([]);
    ctx.fillStyle = ctx.strokeStyle;
    ctx.font = '8px ui-monospace';
    ctx.textAlign = 'center';
    ctx.fillText(ion.type + ion.pos, x, pad.t + 24);
  });
}

// Build candidate rows and wire click handler to toggle ion overlay.
let activeIdx = -1;
const container = document.getElementById('candidates');
scored.forEach((c, i) => {
  const row = document.createElement('div');
  row.className = 'cand-row';
  const total = (c.ions.length);
  row.innerHTML =
    '<span class="cand-seq">' + c.label + '</span>' +
    '<span class="cand-score">Matched <b>' + c.sc + '</b> / ' + total + ' ions</span>' +
    '<button class="show-btn" data-i="' + i + '">Show ions</button>';
  container.appendChild(row);
});

container.addEventListener('click', e => {
  const btn = e.target.closest('button[data-i]');
  if (!btn) return;
  const i = +btn.dataset.i;
  const rows = container.querySelectorAll('.cand-row');
  const btns = container.querySelectorAll('button[data-i]');
  if (activeIdx === i) {
    activeIdx = -1;
    rows.forEach(r => r.classList.remove('selected'));
    btns.forEach(b => { b.classList.remove('active'); b.textContent = 'Show ions'; });
    drawSpectrum(null);
    document.getElementById('status').textContent = '';
  } else {
    activeIdx = i;
    rows.forEach((r, j) => r.classList.toggle('selected', j === i));
    btns.forEach((b, j) => {
      b.classList.toggle('active', j === i);
      b.textContent = j === i ? 'Hide ions' : 'Show ions';
    });
    drawSpectrum(scored[i].ions);
    const best = scored[0];
    const msg = i === 0
      ? i18nFmt('%seq% is the best match with %sc% matched ions.', { seq: scored[i].label, sc: scored[i].sc })
      : i18nFmt('%seq% matches %sc% ions — best is %best% with %bsc%.', { seq: scored[i].label, sc: scored[i].sc, best: best.label, bsc: best.sc });
    document.getElementById('status').textContent = msg;
  }
});

drawSpectrum(null);
Result
Console

Click Show ions for any candidate to see its theoretical fragment masses laid over the observed spectrum. The candidate whose ions overlap the most peaks is the best match — but notice that two candidates can share many peaks, making the decision ambiguous when the spectrum is noisy.

The Real Complexity

How hard is it to recover a sequence from a spectrum?

  • Verification is easy. Given a candidate sequence and a spectrum, computing the theoretical ions and counting matches takes linear time in the sequence length.
  • Database search is tractable in practice — but not in theory. Modern tools (Sequest, Mascot, MaxQuant) score every entry in a protein database against the spectrum. If the database has NN peptides the search is O(N⋅L)O(N \cdot L) where LL is the average peptide length. That is fast when databases are small, but genomic databases now contain billions of candidates.
  • De novo sequencing is NP-hard. When no database is available, the algorithm must reconstruct the sequence from scratch. This is equivalent to finding a path in a spectrum graph — a directed acyclic graph whose nodes are observed peaks and whose edges correspond to amino-acid mass differences. Finding the highest-scoring path through this graph with variable modifications (oxidation, phosphorylation, …) and missing peaks is NP-hard in the general case, as shown by Pevzner and colleagues in work on the Spectral Alignment Problem (2000).
  • The search space explodes with modifications. Each residue can carry one of dozens of chemical modifications. With kk possible modifications per position and a peptide of length LL, the candidate space grows as O(kL)O(k^{L}) — the same exponential barrier that limits knapsack and sequence alignment.

The field bypasses this wall through heuristics, index structures, and machine-learning scoring functions — but the underlying combinatorial hardness never goes away.

Where It Matters

Matching a spectrum to a sequence is not just an academic puzzle — it underpins much of modern biology and medicine:

  • Proteomics and biomarker discovery: identifying which proteins (and in what abundance) differ between healthy and diseased tissue drives the search for cancer, Alzheimer's, and cardiovascular biomarkers.
  • Drug target validation: mass-spec confirms that a drug binds its intended protein and not off-target sites, reading the modification directly from the fragment spectrum.
  • Vaccine and antigen design: peptide mapping tells immunologists exactly which fragments of a pathogen trigger immune responses, guiding epitope-based vaccine design.
  • Food authenticity and safety: species-specific peptides act as fingerprints; a single spectrum run can detect meat fraud or allergen contamination.
  • Microbiome research: metaproteomics identifies the proteins expressed by thousands of microbial species at once, matching millions of spectra against enormous databases — a sequence alignment problem at planetary scale.

Every one of these applications ultimately runs the same combinatorial engine: score candidates, rank them, decide. The computational complexity of that decision is what separates a 10-minute database search from a week-long de novo reconstruction.

Conclusion

A mass spectrometer does not read a protein like a book. It shatters it into pieces and hands you a list of masses. Reassembling the original sequence from that debris is a combinatorial search — easy to verify, hard to solve from scratch, and explosive when chemical modifications enter the picture.

The tools proteomics has built to tame this search — fast scoring heuristics, indexed databases, learned ranking models — are engineering marvels. But they are workarounds for an underlying hardness that touches the same territory as sequence alignment and de novo reconstruction more broadly. The next time a lab report names a protein from a single drop of blood, remember: behind that answer sits a search through an exponential forest of candidates, pruned by decades of algorithmic ingenuity.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/mass-spec-peptide-id/Content licensed under CC BY-NC 4.0.