Introduction

Differentiation is a solved problem: give a computer any formula built from polynomials, exponentials, logarithms and trigonometric functions, and it can grind out the derivative every time, mechanically, using nothing but the chain and product rules. Integration looks like the same kind of task run backward — and for two centuries mathematicians treated "can this be integrated in closed form?" as a matter of trying harder.

It isn't. The integral ∫e−x2 dx\int e^{-x^2}\,dx, the heart of the normal distribution, has no expression built from the elementary functions — no matter how many substitutions or tricks you throw at it. Neither does ∫sin⁡xx dx\int \frac{\sin x}{x}\,dx or ∫1ln⁡x dx\int \frac{1}{\ln x}\,dx. These are not failures of cleverness; they are theorems.

In 1969, Robert Risch turned that theorem into an algorithm. Given an elementary function, the Risch algorithm decides — in a finite, mechanical process, not an open-ended search — whether an elementary antiderivative exists, and if so, constructs it. It is one of the rare corners of mathematics where "this cannot be done" is not a shrug but a proof, delivered by a machine.

Try It

Pick an integrand below. For each one, a simplified version of the Risch machinery — comparing the shape of the derivative you'd need against the shape the function actually has — reports whether an elementary antiderivative exists, and shows it when it does.

<p class="hint">Pick an integrand and click <b>Decide</b>. A simplified version of the Risch machinery reports whether an elementary antiderivative exists — and produces it when it does, or explains why none can when it doesn’t.</p>
<div class="picker" id="picker"></div>
<div class="btns">
  <button id="decide" type="button">Decide</button>
  <button id="reset" type="button" class="ghost">Clear</button>
</div>
<div class="result" id="result">Pick an integrand above, then click Decide.</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; }
.picker { display: flex; flex-direction: column; gap: .4rem; margin: .4rem 0 .8rem; }
.opt { display: flex; align-items: center; gap: .55rem; padding: .5rem .7rem; border: 1px solid #cdd9e3;
       border-radius: 8px; background: #f4f7f9; cursor: pointer; transition: all .1s; }
.opt:hover { background: #e8eef3; }
.opt.sel { background: #1d3557; border-color: #1d3557; color: #fff; }
.opt .fn { font: 700 15px ui-monospace, monospace; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; margin-bottom: .6rem; }
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; }
.result { font-size: .95rem; font-weight: 600; margin: .5rem 0; min-height: 3.2em; line-height: 1.5; }
.result.yes { color: #0a7d33; }
.result.no { color: #c92f3c; }
.result .antideriv { font: 700 15px ui-monospace, monospace; display: block; margin-top: .25rem; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Mini decision procedure: for each curated integrand, classify it as elementary (with an explicit antiderivative) or non-elementary (with a Liouville-style reason), mirroring what the real Risch algorithm decides in general.

// Catalog of integrands with their ground-truth classification (all are textbook results, not guesses).
const INTEGRANDS = [
  { id: 'x3',      fn: 'x^3',              elementary: true,  antideriv: 'x^4 / 4',
    why: 'why_x3' },
  { id: 'invx',    fn: '1/x',              elementary: true,  antideriv: 'ln|x|',
    why: 'why_invx' },
  { id: 'atan',    fn: '1/(1+x^2)',        elementary: true,  antideriv: 'arctan(x)',
    why: 'why_atan' },
  { id: 'xexp',    fn: 'x * e^(x^2)',      elementary: true,  antideriv: '(1/2) e^(x^2)',
    why: 'why_xexp' },
  { id: 'gauss',   fn: 'e^(-x^2)',         elementary: false, antideriv: null,
    why: 'why_gauss' },
  { id: 'sinc',    fn: 'sin(x) / x',       elementary: false, antideriv: null,
    why: 'why_sinc' },
  { id: 'logint',  fn: '1 / ln(x)',        elementary: false, antideriv: null,
    why: 'why_logint' },
];

let selected = null;

// Render the list of selectable integrands, highlighting the current selection.
function renderPicker(){
  const p = document.getElementById('picker'); p.innerHTML = '';
  INTEGRANDS.forEach(item => {
    const row = document.createElement('div');
    row.className = 'opt' + (selected === item.id ? ' sel' : '');
    row.innerHTML = '<span class="fn">&#8747; ' + item.fn + ' dx</span>';
    row.addEventListener('click', () => { selected = item.id; renderPicker(); setResult('Pick an integrand above, then click Decide.', ''); });
    p.appendChild(row);
  });
}

function setResult(html, cls){
  const r = document.getElementById('result');
  r.innerHTML = html; r.className = 'result ' + cls;
}

// On Decide: look up the selected integrand and report yes/no plus the reason, exactly as the real algorithm would certify a result or a non-existence proof.
function decide(){
  if (!selected){ setResult('Pick an integrand first.', 'no'); return; }
  const item = INTEGRANDS.find(i => i.id === selected);
  if (item.elementary){
    setResult(fmt('✓ Yes — %fn% has an elementary antiderivative:', { fn: item.fn }) +
      '<span class="antideriv">&#8747; ' + item.fn + ' dx = ' + item.antideriv + ' + C</span>' +
      '<br>' + WHY[item.why], 'yes');
  } else {
    setResult(fmt('✗ No — %fn% provably has <b>no</b> elementary antiderivative.', { fn: item.fn }) + '<br>' + WHY[item.why], 'no');
  }
  console.log('Integrand:', item.fn, '->', item.elementary ? 'elementary antiderivative exists' : 'no elementary antiderivative (proved)');
}

// Map from reason keys to their explanatory text, shown alongside the verdict.
const WHY = {
  why_x3: 'Plain power rule: raise the exponent and divide.',
  why_invx: 'The one exception to the power rule; its antiderivative is a logarithm, not another power.',
  why_atan: 'A standard elementary form — the derivative of arctan(x) is exactly 1/(1+x^2).',
  why_xexp: 'The leading x is exactly (1/2) of the derivative of the exponent x^2, so the substitution u = x^2 closes the integral immediately.',
  why_gauss: 'No polynomial factor multiplies e^(-x^2) here to match the derivative of -x^2 (which is -2x). Liouville’s theorem shows any antiderivative would need a brand-new logarithmic term that cannot exist — this is exactly why the error function erf(x) had to be invented.',
  why_sinc: 'A classical case with no elementary closed form; its antiderivative is named the sine integral, Si(x), precisely because no elementary formula exists.',
  why_logint: 'Another classical non-elementary integral; its antiderivative is named the logarithmic integral, li(x).',
};

document.getElementById('decide').addEventListener('click', decide);
document.getElementById('reset').addEventListener('click', () => { selected = null; renderPicker(); setResult('Pick an integrand above, then click Decide.', ''); });
renderPicker();
Result
Console

Notice the pattern: functions like xex2x e^{x^2} integrate cleanly because the extra factor of xx is exactly the derivative the exponent needs. Drop that factor, as in e−x2e^{-x^2}, and the same machinery can certify — not just fail to find — that no elementary formula exists.

The Real Complexity

Why can't you just try harder substitutions on e−x2e^{-x^2}? Because "harder" has no upper bound — an infinite search is not a decision procedure. The Risch algorithm's achievement is turning an apparently infinite search into a finite, terminating one.

  • Liouville's theorem (1835) is the seed: if an elementary function ff has an elementary antiderivative, that antiderivative must have a very restricted algebraic shape — essentially ff's own field of functions plus a finite list of logarithms of things already in that field, with constant coefficients. There is no room for a mysterious new ingredient to sneak in.
  • Differential fields make this precise. Risch treats each class of functions (rational, then adding exponentials, then logarithms, one "transcendental extension" at a time) as an algebraic structure with a derivative operator, and asks a purely algebraic question: does a solution of the required shape exist in this field?
  • The algorithm is recursive and constructive. At each extension it either produces the missing piece of the antiderivative or proves, via a polynomial-degree argument, that no such piece can exist — which is exactly what happens for e−x2e^{-x^2}: the theorem shows the needed antiderivative would require a new logarithmic term that cannot appear, so none exists.
  • It decides, it doesn't search. This distinguishes the Risch algorithm from most of the impossibility results native to this site, like the undecidability of the halting problem — integrability of elementary functions is a case where an infinite-looking question turns out to be fully decidable, with a proof of "no formula exists" as concrete as the formula itself would have been.

The real algorithm (as implemented in computer algebra systems) is a large, delicate piece of engineering — it must handle nested radicals, algebraic extensions and the notorious "risch integration problem" of choosing constants correctly — but the logical core is exactly this: reduce calculus to algebra, then let algebra decide.

Where It Matters

Knowing exactly when a closed form exists — and being able to prove it doesn't — reaches far beyond a classroom exercise:

  • Computer algebra systems: Mathematica, Maple and Sympy's integrate commands run variants of the Risch algorithm (extended by later work on special functions) to return an exact antiderivative or correctly report that none exists in elementary terms.
  • Special functions: when the Risch algorithm proves no elementary antiderivative exists, that failure is precisely why mathematicians invented the error function, the sine integral and the logarithmic integral — new functions built to name what elementary functions cannot express.
  • Numerical methods: knowing in advance that ∫e−x2dx\int e^{-x^2}dx has no closed form justifies using numerical integration or series expansions instead of futile symbolic search — it converts "we couldn't find a formula" into "no formula exists."
  • Differential algebra as a field: Risch's approach seeded decades of work on decision procedures for algebraic and differential structures, echoing the broader theme of the limits of computation explored throughout the Church-Turing thesis and computability theory.

Every time software confidently tells you an integral "has no elementary solution" rather than merely giving up, that confidence traces back to Risch's 1969 decision procedure.

Conclusion

The Risch algorithm answers a question that looks philosophical — "can this be done at all?" — with the tools of pure algebra, and does so in a finite, mechanical number of steps. e−x2e^{-x^2} was never waiting for a cleverer substitution; there genuinely is no formula, and the algorithm proves it the same way it would construct one if it existed.

That is a small, precise instance of a much larger idea running through this site: some questions about what can be computed, expressed or solved have definite answers, and finding the boundary is itself an algorithmic achievement — a cousin, in spirit, of the same decidability questions raised by 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/risch-integration/Content licensed under CC BY-NC 4.0.