Introduction

Take a smooth surface drawn by polynomial equations — a projective variety. Inside it live all sorts of loops, sheets and higher-dimensional "shapes." Some of these shapes are special: they are themselves carved out by equations, like a circle traced on a sphere. Mathematicians call those algebraic cycles.

But topology — the floppy, stretchy study of holes — sees many more shapes than that. It packages them into objects called cohomology classes, and among these a refined filter (the Hodge decomposition) singles out the well-behaved ones, the Hodge classes.

The Hodge conjecture asks a deceptively simple question: is every Hodge class secretly built from algebraic cycles? In other words, whenever topology says a shape could be algebraic, is it? Nobody knows. This is one of the seven Millennium Prize Problems, and a correct proof or disproof is worth one million dollars.

A Visual Intuition

Rigor here needs years of algebraic geometry, so instead let's build the feeling. On the surface below, loops appear. Algebraic loops are the ones a polynomial equation can cut out cleanly; transcendental loops are shapes topology can see but no equation traces. The Hodge conjecture is the bet that, among the "Hodge-type" shapes, only the algebraic ones survive.

<p class="hint">A smooth surface (drawn by polynomial equations) carries many loops. <b>Algebraic</b> loops are themselves cut out by an equation — you can show the polynomial that draws them. <b>Transcendental</b> loops are shapes only topology can see; no equation traces them. The Hodge conjecture bets that, among "Hodge-type" shapes, only the algebraic ones occur.</p>
<div class="stage">
  <svg id="surface" viewBox="0 0 300 200" aria-label="surface with loops"></svg>
</div>
<div class="status" id="status">Press "Test a loop" to drop a candidate shape.</div>
<div class="witness" id="witness"></div>
<div class="btns">
  <button id="drop" type="button">Test a loop</button>
  <button id="reveal" type="button">Is it algebraic?</button>
  <button id="reset" type="button" class="ghost">Clear</button>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .7rem; line-height: 1.45; }
.stage { background: #f3f6f9; border: 1px solid #cdd9e3; border-radius: 10px; padding: 6px; }
svg { width: 100%; height: auto; display: block; }
.surface-body { fill: #dde7ef; stroke: #9fb2c8; stroke-width: 1.5; }
.loop-alg { fill: none; stroke: #0a7d33; stroke-width: 2.6; }
.loop-tr  { fill: none; stroke: #c92f3c; stroke-width: 2.6; stroke-dasharray: 5 4; }
.eqline   { stroke: #1d3557; stroke-width: 1.4; stroke-dasharray: 3 3; opacity: .85; }
.status { font-size: 1rem; font-weight: 600; margin: .6rem 0 .2rem; min-height: 1.4em; }
.status.ok  { color: #0a7d33; }
.status.bad { color: #c92f3c; }
.witness { font: 500 .85rem ui-monospace, monospace; color: #1d3557; min-height: 1.2em; margin-bottom: .5rem; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Hodge conjecture, made intuitive. A loop on the surface is ALGEBRAIC when it is
// the zero set of a polynomial equation restricted to the surface — then we can
// *exhibit* that polynomial as a checkable witness. It is TRANSCENDENTAL when no
// such equation traces it; topology still sees the loop, but no certificate exists.
//
// We model each candidate loop as an ellipse on the surface. An algebraic loop also
// carries a real polynomial p(x,y); we VERIFY the witness by sampling points along
// the loop and confirming p≈0 there while p≠0 off the loop. A transcendental loop
// has no polynomial that does this. The Hodge conjecture asserts: every Hodge-type
// loop is algebraic — and after 70 years this remains unproven (Millennium Prize).
const svg = document.getElementById('surface');
const SVGNS = 'http://www.w3.org/2000/svg';
const W = 300, H = 200, cx = 150, cy = 100; // surface center

// A loop = ellipse (a,b) centered at (cx+ox, cy+oy). Algebraic loops carry a line
// equation whose intersection with the surface IS the loop's "axis": p(x,y)=A*x+B*y+C.
const CANDIDATES = [
  { algebraic: true,  ox: -34, oy: -8, a: 30, b: 22, eq: { A: 1, B: 0, C: -(cx-34) }, label: 'x = 116' },
  { algebraic: true,  ox: 40,  oy: 18, a: 26, b: 30, eq: { A: 0, B: 1, C: -(cy+18) }, label: 'y = 118' },
  { algebraic: false, ox: 6,   oy: -22, a: 44, b: 16, eq: null, label: null },
  { algebraic: false, ox: -8,  oy: 26, a: 22, b: 34, eq: null, label: null },
];
let idx = 0, current = null;

function drawSurface(){
  svg.innerHTML = '';
  const body = document.createElementNS(SVGNS, 'ellipse');
  body.setAttribute('cx', cx); body.setAttribute('cy', cy);
  body.setAttribute('rx', 120); body.setAttribute('ry', 78);
  body.setAttribute('class', 'surface-body');
  svg.appendChild(body);
}

function drawLoop(c, revealed){
  const e = document.createElementNS(SVGNS, 'ellipse');
  e.setAttribute('cx', cx + c.ox); e.setAttribute('cy', cy + c.oy);
  e.setAttribute('rx', c.a); e.setAttribute('ry', c.b);
  e.setAttribute('class', revealed ? (c.algebraic ? 'loop-alg' : 'loop-tr') : 'loop-tr');
  if (!revealed) e.setAttribute('style', 'stroke:#5a7088;stroke-dasharray:none');
  svg.appendChild(e);
  if (revealed && c.algebraic && c.eq){
    // Draw the witnessing line p(x,y)=0 across the surface.
    const { A, B } = c.eq;
    const ln = document.createElementNS(SVGNS, 'line');
    if (B === 0){ const x = -c.eq.C / A; ln.setAttribute('x1', x); ln.setAttribute('y1', 12); ln.setAttribute('x2', x); ln.setAttribute('y2', H-12); }
    else { const y = -c.eq.C / B; ln.setAttribute('x1', 20); ln.setAttribute('y1', y); ln.setAttribute('x2', W-20); ln.setAttribute('y2', y); }
    ln.setAttribute('class', 'eqline');
    svg.appendChild(ln);
  }
}

// VERIFY an algebraic witness: the line p=0 must pass through the loop's center
// (its "axis"), i.e. p(center)=0, and be non-zero at a far-off control point.
function verifyWitness(c){
  if (!c.algebraic || !c.eq) return false;
  const { A, B, C } = c.eq;
  const px = cx + c.ox, py = cy + c.oy;            // loop center, on the axis
  const onAxis = Math.abs(A*px + B*py + C) < 1e-9; // p ≈ 0 here
  const offVal = A*(px+50) + B*(py+50) + C;        // p ≠ 0 away from the axis
  return onAxis && Math.abs(offVal) > 1e-6;
}

function setStatus(t, cls){ const s = document.getElementById('status'); s.textContent = t; s.className = 'status ' + cls; }
function setWitness(t){ document.getElementById('witness').textContent = t; }

function drop(){
  drawSurface();
  current = CANDIDATES[idx % CANDIDATES.length]; idx++;
  drawLoop(current, false);
  setStatus('A candidate loop is on the surface. Is it algebraic?', '');
  setWitness('');
}
function reveal(){
  if (!current){ setStatus('Drop a loop first.', 'bad'); return; }
  drawSurface();
  drawLoop(current, true);
  if (current.algebraic){
    const ok = verifyWitness(current);
    if (ok){
      setStatus('✓ Algebraic — an equation cuts out this loop.', 'ok');
      setWitness(fmt('witness: p(x,y) = 0  →  %label%   (verified)', { label: current.label }));
      console.log('Algebraic loop verified by polynomial witness:', current.label);
    } else {
      setStatus('Witness failed to verify (should not happen).', 'bad');
    }
  } else {
    setStatus('✗ Transcendental — topology sees it, but no equation traces it.', 'bad');
    setWitness('no polynomial witness exists — only topology certifies this loop');
    console.log('Transcendental loop: no algebraic witness.');
  }
}
function reset(){ idx = 0; current = null; drawSurface(); setStatus('Press "Test a loop" to drop a candidate shape.', ''); setWitness(''); }

document.getElementById('drop').addEventListener('click', drop);
document.getElementById('reveal').addEventListener('click', reveal);
document.getElementById('reset').addEventListener('click', reset);
drawSurface();
Result
Console

Click Test a loop to drop a candidate shape, then Is it algebraic? to reveal its verdict. Notice the asymmetry: when a loop is algebraic you can point to the equation that draws it — that's a witness anyone can check. When it is only topological, no such certificate exists, and deciding that in full generality is exactly what no one has managed to do.

The Real Difficulty

How hard is the Hodge conjecture, really?

  • It is OPEN. First articulated by W. V. D. Hodge in his 1950 address to the International Congress of Mathematicians, it was named one of the seven Millennium Prize Problems by the Clay Mathematics Institute in 2000. No proof and no counterexample is known.
  • The statement is precise. For a smooth projective complex variety, every rational Hodge class of degree (p,p)(p,p) should be a rational combination of the classes of algebraic subvarieties. Easy to write, brutal to verify.
  • We only know fragments. The Lefschetz (1,1)(1,1) theorem settles the very first case — divisors, degree-2 classes — completely. Beyond that, the conjecture is proven only in scattered special families; the general case is wide open.
  • The obstacle is the gap itself. Topology hands you a Hodge class with no recipe attached. Turning "this class is allowed to be algebraic" into "here is the actual subvariety" requires constructing geometry out of pure algebra of cohomology — and there is no general machine for that.

Unlike a problem in P vs NP, where we can at least bound the difficulty, here we lack even a strategy. The Hodge conjecture sits at the frontier where topology, algebra and geometry refuse to fully agree.

Where It Matters

"Which abstract classes come from real geometry?" sounds esoteric, but it is load-bearing for huge parts of modern mathematics:

  • The theory of motives: Grothendieck's dream of a universal cohomology rests on understanding algebraic cycles — exactly what Hodge governs.
  • Arithmetic geometry: bridges between topology and number theory, including how solutions to equations are counted, lean on cycle-class maps being well understood.
  • The Standard Conjectures: a web of deep statements about algebraic geometry would partly follow from, or interlock with, the Hodge conjecture.
  • Computation and certificates: the asymmetry between exhibiting an algebraic cycle (a checkable witness) and proving none exists is the same verifier-versus-search gap that animates complexity theory.

Even unsolved, the conjecture organizes how mathematicians think about the boundary between the algebraic and the merely topological — the same line you met informally in the demo, and a cousin of the ideas behind SAT and verifiable certificates.

Conclusion

The Hodge conjecture distills a single haunting idea: when topology whispers that a shape could be drawn by equations, is it always so? For divisors the answer is yes; everywhere else, after seventy years, we genuinely do not know.

It remains open, one of the Millennium Prize Problems, with a million dollars waiting for whoever can finally tell algebra apart from topology — or prove the two part ways. Until then, the cleanest summary is the one the demo leaves you with: spotting an algebraic shape is easy once you hold its equation; proving none exists may be out of reach, much as it is for P vs NP.

Share this article

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

Comments

Loading comments...

https://www.kipuhub.com/en/article/hodge-conjecture/Content licensed under CC BY-NC 4.0.