The Constant-Product Formula: x · y = k

Last lesson left you with a promise: an AMM prices trades against a pool using a formula, and that formula is the whole magic trick. Here it is, in all its anticlimactic glory:

$x \cdot y = k$

Two reserves. Multiply them. Keep the answer constant. That single line decides the price of every swap, why big trades cost more, why the pool can never run dry, and how liquidity providers get paid. It’s the most consequential multiplication in decentralized finance — and once it clicks, the rest of AMMs is just footnotes. Let’s make it click.

The invariant: keep the product constant

Call the two reserves $x$ and $y$ — say $x$ is the ETH in the pool and $y$ is the USDC. The pool lives by one rule:

$x \cdot y = k$

where $k$ is a fixed number, the invariant. A swap is allowed to change $x$ and to change $y$ as much as it likes — but it must leave their product $k$ unchanged. You put one token in (that reserve goes up), you take the other token out (that reserve goes down), and the contract picks exactly how much comes out so that the product still equals $k$.

Think of it as a seesaw with a very specific rule: the two seats can move freely, but the area of the rectangle they trace out is bolted to a constant. Push one side down and the other side must rise — and not by an equal amount, by whatever keeps the product fixed.

Plug in our numbers. A pool of 100 ETH and 200,000 USDC has:

$k = 100 \times 200000 = 20{,}000{,}000$

That 20 million is the pool’s identity card. Every legal state of this pool — every combination of ETH and USDC it can be in after any sequence of swaps — sits on the curve where $x \cdot y = 20{,}000{,}000$.

Spot price = the ratio of the reserves

So where’s the price? It’s the ratio of the two reserves. The spot price of ETH in terms of USDC is:

$\text{price} = \frac{y}{x} = \frac{\text{USDC reserve}}{\text{ETH reserve}}$

For our pool:

$\text{price} = \frac{200000}{100} = 2000$

One ETH is quoted at $2000. Intuitively: there are 2000 USDC sitting in the pool for every 1 ETH, so the pool values them at 2000-to-1. This is the spot price — the price for an infinitesimally small trade, the slope of the curve at the pool’s current point. The instant you trade a real, finite amount, the ratio shifts and the price you actually pay drifts away from it. That gap is the whole story of the next section.

A swap walks the pool along the curve

Here’s the geometric picture that makes everything intuitive. Rearrange the invariant:

$y = \frac{k}{x}$

That’s a hyperbola — a curve that swoops down steeply on the left, flattens in the middle, and hugs the axes at the extremes. Every possible state of the pool is a single point sliding along this curve. A swap doesn’t jump the point somewhere new; it walks it along the hyperbola from the old reserves to the new ones.

To swap, you sell an amount $\Delta x$ of token X into the pool. The new reserves are:

• New X reserve: $x' = x + \Delta x$ (you added X)
• New Y reserve: $y' = \dfrac{k}{x'}$ (forced by the invariant)
• Y you receive: $\Delta y = y - y'$ (the drop in the Y reserve)

Let’s grind a real example. You want to buy ETH by adding 2,000 USDC. Here ETH is the token leaving (X) and USDC is the token entering (Y), so it’s cleanest to track the USDC reserve as the one we add to:

• Old reserves: 100 ETH, 200,000 USDC, with $k = 20{,}000{,}000$.
• Add 2,000 USDC → new USDC reserve $y' = 200000 + 2000 = 202000$.
• Invariant forces the new ETH reserve: $x' = \dfrac{k}{y'} = \dfrac{20000000}{202000} \approx 99.0099$.
• ETH you receive: $100 - 99.0099 \approx 0.990$ ETH.

So 2,000 USDC bought you about 0.990 ETH. What price did you actually pay?

$\text{average price} = \frac{2000}{0.990} \approx 2020$

You paid about $2020 per ETH — already worse than the $2000 spot price you saw before you traded, even though you only nudged the pool by a couple thousand dollars. And the pool’s new spot price has moved too:

$\text{new price} = \frac{202000}{99.0099} \approx 2040$

The next person buying ETH starts from $2040, not $2000. Your trade pushed the price up, and it stays up until someone trades the other way. Drag the slider below and watch the pool point crawl along the curve — the readouts show your average price diverging from spot as the trade grows.

Why bigger trades pay worse prices

Notice the pattern in the worked example: a tiny trade pays ≈ spot, but the price you actually get degrades as the trade grows. That’s not a bug — it falls straight out of the curve’s shape. The hyperbola is convex: the deeper you push a reserve, the steeper the trade-off gets, so each additional unit you buy costs more than the one before it.

A quick feel for the scale, all from the same 100 ETH / 200,000 USDC pool:

Spend 1% of the pool and you barely notice ($2020 vs $2000). Spend half the pool and you pay 50% over spot. The lesson: small trades ≈ spot price; big trades pay much more, and the penalty accelerates. This worsening is the seed of price impact / slippage, which gets its own full lesson (lesson 4) — for now, just internalize that the curve, not a fee, is what makes size expensive.

The fee: how LPs actually get paid

So far the math has been frictionless, and a frictionless pool would pay its liquidity providers nothing. Real AMMs add a swap fee. The classic Uniswap v2 fee is 0.3%, and the mechanism is delightfully simple: the fee is skimmed off your input and left inside the pool rather than traded against the curve.

Concretely, when you add 2,000 USDC with a 0.3% fee:

• The fee is $0.003 \times 2000 = 6$ USDC.
• Only 99.7% of your input — 1,994 USDC — actually trades against the curve and determines your ETH out.
• The 6 USDC of fee is deposited into the pool anyway.

Because the fee tokens stay in the pool without buying any ETH out, the pool ends each swap holding slightly more than the invariant strictly required — so $k$ doesn’t stay perfectly constant, it ticks up a hair every single swap. That slow, relentless growth of $k$ is exactly the LPs’ income: their share of the pool now represents a bigger pile of reserves than they put in. Every trade fattens the pool a little, and LPs own a slice of the fattening. (This is why lesson 1’s ”$x \cdot y = k$ stays constant” came with a quiet almost — fees nudge it upward.)

Key Takeaways

Next up: liquidity providers and LP tokens — who actually fills the pool, what they receive for it, and how that creeping $k$ turns into their paycheck.