Two answers to the same question
Every method in the earlier rungs of this ladder shared one quiet assumption: the answer would be a number, and that number would be approximate. We solved A x = b and got 2.9999999998 instead of 3; we ran Newton's method and watched the digits pile up but never become exact; we always worked inside floating-point arithmetic, where 0.1 has no exact binary form. That is numerical computation, and it is one of two great styles. This rung is about the other one.
In symbolic computation, the computer does not handle numbers so much as expressions. Ask it for the derivative of x^3 and it returns the exact expression 3 x^2, not a table of slopes. Ask it for the integral of 1/x and it returns log(x), letter for letter. Ask it to add 1/3 and 1/6 and it returns exactly 1/2 — never 0.5, never 0.4999999. The object it carries is a tree of symbols: a plus node with two children, a power node, a variable named x. The contrast between these two styles is the single idea this whole rung is built on; the glossary calls it symbolic vs numerical computation.
What "exact" really buys you
The foundation of exactness is that the machine refuses to round. Where floating-point keeps about 16 decimal digits and throws the rest away, a CAS stores numbers in forms that lose nothing. The simplest is exact rational arithmetic: a fraction is just a pair of whole numbers, a numerator and a denominator, so 1/3 stays the pair (1, 3) forever and never decays into 0.3333. Add two fractions and you get another exact fraction, reduced by cancelling their common factor. There is no round-off floor here at all — the very thing that limited numerical accuracy simply does not exist.
But whole numbers can grow far past the 64 bits a machine register holds. Multiply enough integers together — say, computing 50 factorial — and the result is a 65-digit number that no single register can store. The answer is arbitrary-precision arithmetic, often called bignum: an integer is stored as an array of digit-chunks, and the system carries as many chunks as the value needs, doing grade-school carrying across them. It is slower than hardware arithmetic — a bignum multiply costs more as the numbers lengthen — but it is exact for integers of any size, and exact rationals are simply two bignums riding together.
Beyond rationals, a CAS keeps irrational and transcendental quantities as themselves. The square root of 2 is stored as the symbol sqrt(2), not as 1.41421356; pi is stored as pi. Then sqrt(2) times sqrt(2) collapses to exactly 2, and a million such operations introduce zero error, because no approximation was ever made. This is the great prize of the symbolic style: an answer of pi/2 is the truth, not a 16-digit shadow of it, and it stays the truth no matter how long the calculation runs.
The hidden hard part: deciding when two things are equal
Here is where symbolic computation reveals a difficulty with no echo in the numerical world. If two numbers differ, you see it instantly — 3.0 is not 3.1. But are the expressions (x + 1)^2 and x^2 + 2 x + 1 equal? They are, of course, but they look completely different on the page. A CAS that cannot tell will give clumsy, redundant answers and may never simplify anything. So every system needs a way to bring an expression to a single agreed-upon shape, a canonical form: a rule that says "however you wrote this, here is the one standard way to write it." Reduce both expressions to canonical form and, if they match character for character, they are equal.
For polynomials this works beautifully — expand everything and collect like terms, and both sides above become x^2 + 2 x + 1. But step outside polynomials and the ground gives way. Is the expression sin(x)^2 + cos(x)^2 - 1 equal to zero? It is, but only if the system knows the Pythagorean identity. Is exp(log(x)) - x zero? Only for x greater than zero. Deciding whether an arbitrary expression is identically zero is the zero-equivalence problem, and the honest, unsettling truth is that for rich enough classes of expressions it is provably undecidable — no algorithm can always answer it. This is not a gap waiting to be filled by a cleverer engineer; it is a hard limit baked into mathematics itself.
When does each kind win?
So you have two toolkits. Which do you reach for? The decision turns on what you actually need from the answer, and the two styles have almost opposite sweet spots. Symbolic wins when you need a formula rather than a value — a result you can read, differentiate by hand, or specialize to many inputs later. Numerical wins when you need a number now, when the problem has no closed-form answer at all (which is most real problems), or when the symbolic answer would be too monstrous to use.
- Reach for symbolic when you want an exact formula you can inspect — say, the antiderivative of a function, the general solution of a small system, or a closed-form expression you will reuse with many different parameter values.
- Reach for numerical when you want a concrete value, when the problem has no closed form (a turbulent flow, a market, a galaxy), or when speed and large size matter more than seeing the algebra.
- Combine them, which is what experts actually do: derive a clean formula symbolically to be sure it is right, then hand that formula to a fast numerical routine to evaluate it at scale. Each style covers the other's blind spot.
A concrete picture: suppose you must integrate a function. A CAS may hand you an exact antiderivative in seconds — wonderful, you now have a formula valid for every input. But many perfectly ordinary functions, like exp(-x^2), have no antiderivative expressible in elementary functions at all; the symbolic engine will correctly tell you so. For those, the only road is numerical quadrature, the approximate-area methods from the quadrature rung, which never fail to return a number even when no formula exists. Neither style is superior; they answer different questions.
The catch that shadows everything
If exact symbolic computation is so powerful — no round-off, the literal truth — why is the whole world not symbolic? Because exactness has a brutal price tag, and it has its own name: expression swell. As a symbolic calculation proceeds, the intermediate expressions can balloon explosively, even when the input and the final answer are both small and tidy. A determinant of a modest symbolic matrix can detonate into thousands of terms; the numerator and denominator of an exact fraction can each grow to hundreds of digits long mid-computation, only to cancel back down at the end.
This is the symbolic mirror image of the limitations you met numerically. In the numerical world the central enemy was round-off error and ill-conditioning — a condition number near 10^8 quietly eating half your digits. In the symbolic world there is no round-off at all, but the cost of storing and manipulating those exact expressions can explode so fast that a calculation runs out of memory or time long before it finishes. Exactness does not scale, and the final guide of this rung is devoted entirely to why.
Keep this whole rung's map in mind as you climb it. Next you will look closely at how exactness is actually built — arbitrary precision and the canonical forms that make equality decidable for nice cases. Then the algebra of polynomials: GCDs by a polynomial Euclidean algorithm and Groebner bases for whole systems of polynomial equations. Then symbolic calculus, including the remarkable Risch algorithm that can decide whether an integral even has an elementary form. And finally expression swell, the wall that every symbolic method eventually meets. Two kinds of computing, two kinds of limit — and a mature computational mathematician knows exactly when to switch between them.