Visual walkthrough — Guardrails and constrained generation

We assume nothing. If a symbol appears, we drew it first.

---

Step 1 — What a language model actually hands you at each step

WHAT. A language model does not "write words". At every single step it produces one number for every possible token (a token ≈ a word-piece). Call these numbers the logits. If the vocabulary has, say, 6 tokens, you get 6 numbers. That's it — a bare list of scores.

WHY. Before we can bend generation, we must know exactly what raw material we are bending. The raw material is a vector of scores, one per token — nothing is a "probability" yet. A logit can be any real number: big positive means "I like this token", big negative means "I dislike it", zero means "meh".

PICTURE. Look at the blue bars in the figure: six tokens, six heights. Some bars point up (positive logit), one points down (negative logit — token "z" at $-3$). Height = the model's raw enthusiasm. Notice nothing here sums to 1; these are not yet probabilities.

---

Step 2 — Softmax: turning scores into a probability pie

WHAT. To choose a token we need probabilities (numbers in $[0,1]$ that add to $1$). The recipe that does this is softmax. For token $i$:

$$P(x_t=i)=\frac{\stackrel{\text{this token’s weight}}{\overbrace{e^{{\text{logits}}_t[i]}}}}{\underset{\text{total weight of all tokens}}{\underbrace{\sum _j{e}^{{\text{logits}}_t[j]}}}}$$

Term by term: $e^{(\cdot )}$ takes each score and makes it positive (so no negative probabilities); the numerator is this token's positive weight; the denominator adds up everyone's weight so the fractions sum to exactly $1$.

WHY softmax and not just "divide the logits"? Because logits can be negative, and you cannot have a negative probability. The exponential $e^x$ is the natural fixer: it maps every real number to a positive one, it is monotonic (bigger logit → bigger probability), and the division makes them a valid pie that sums to $1$.

PICTURE. The blue logit bars from Step 1 become a yellow pie. The down-pointing token "z" (logit $-3$) did not vanish — $e^{-3}\approx 0.05$ is small but not zero. It still gets a thin slice. Hold onto that fact: a low logit is still a possible token.

Recall

Why can't a logit of $-3$ ever give probability $0$? ::: Because $P=e^{-3}/(\text{sum})$ and $e^{-3}\approx 0.0498\ne 0$. The exponential of any finite number is strictly positive.

---

Step 3 — The constraint: a machine that says "yes" or "no" to each next token

WHAT. A constraint (JSON schema, a regex, a grammar) can always be turned into a finite-state machine: a little diagram of states with arrows. You are always sitting in one state; each token either follows a legal arrow (allowed) or has no arrow (forbidden).

WHY a machine and not just "check at the end"? Because we want to forbid the bad token before it is generated. To do that we need, at every step, a crisp yes/no verdict for each token: "does this keep me on a valid path?" A finite-state machine gives exactly that verdict instantly from the current state. (This is the same machine idea behind function calling schemas.)

PICTURE. The tiny machine for the regex \d\d ("two digits"): state $S_0$ →(any digit)→ $S_1$ →(any digit)→ $S_2$ (accept). Standing in $S_0$, the only legal tokens are digits; letters and punctuation have no arrow — they are forbidden. Green arrows = allowed, red dashed = forbidden.

---

Step 4 — The naive fix that looks clean and is wrong: multiply by 0

WHAT. The tempting idea: build a mask that is $1$ for valid tokens and $0$ for invalid ones, then multiply the logits by it: $\text{logits}\odot \text{mask}$ (here $\odot$ means "multiply element by element").

WHY it feels right. Multiplying a forbidden token by $0$ seems to "erase" it, and the notation is pretty.

WHY it is actually broken — two separate disasters, both visible in the figure:

1. A forbidden token whose logit was $+4$ becomes $4\times 0=0$. But $e^0=1>0$, so after softmax it still gets a slice. It was not erased at all.
2. Worse: a forbidden token whose logit was negative, say $-3$, becomes $-3\times 0=0$ — which is larger than $-3$. Multiplying boosted it. The forbidden token got more likely.

$$\underset{\text{forbidden, unlikely}}{\underbrace{-3}}\times 0=\underset{\text{forbidden, now MORE likely!}}{\underbrace{0}}$$

PICTURE. Left panel: original logits. Right panel after multiplying-by-0: the two forbidden bars (red) both flattened to height $0$ — and the previously-negative one visibly rose. The red slice in the resulting pie is not zero; it grew.

---

Step 5 — The real fix: ADD $-\infty$ before the softmax

WHAT. Instead of multiplying, we add a bias. Build ${\text{maskbias}}_t$:

$${\text{maskbias}}_t[i]=\{\begin{array}{ll}0& \text{token }i\text{ valid}\\ -\infty & \text{token }i\text{ invalid}\end{array}$$

Then compute the constrained probabilities:

$$P(x_t=i\mid \text{constraint})=\text{softmax}(\underset{\text{model’s wish}}{\underbrace{{\text{logits}}_t}}+\underset{\text{gate: 0 or }-\infty }{\underbrace{{\text{maskbias}}_t}})$$

Term by term: valid tokens get $+0$ — untouched, the model keeps its opinion. Invalid tokens get $+(-\infty )$ — sent to negative infinity, no matter what they started at.

WHY $-\infty$ and why add? Because softmax's first move is $e^{(\cdot )}$, and:

$$e^{\text{logit}+(-\infty )}=e^{-\infty }=0$$

Addition drags every forbidden logit to $-\infty$ regardless of its starting value — this cures both disasters of Step 4 at once: the $+4$ token and the $-3$ token both land at $-\infty$, both become $e^{-\infty }=0$. A token contributing $0$ to the numerator gets exactly $0$ probability, and it also adds $0$ to the denominator, so the remaining valid tokens automatically renormalize to sum to $1$.

PICTURE. Same six tokens. Green (valid) bars keep their height; red (invalid) bars are shoved off the bottom of the chart to $-\infty$. The resulting pie has only green slices, and they sum to $1$ on their own.

---

Step 6 — The degenerate case: in practice we never use literal $-\infty$

WHAT. Computers cannot store $-\infty$ cleanly; $e^{-\infty }$ can produce NaN (Not-a-Number) in edge arithmetic. So real code uses a huge finite negative number, typically $-10^9$.

WHY it still works. We don't need exactly zero; we need unimaginably tiny. If a valid logit is around $10$ and a masked one is $-10^9$, then:

$$e^{-10^9}\approx 0\text{vs.}{e}^{10}\approx 22026$$

The masked token's slice is smaller than any number your machine can represent — effectively zero — but the arithmetic stays finite and safe.

PICTURE. A number line. Real logits cluster near $0$ (blue dots). The mask value $-10^9$ sits so far left it's off-screen (red arrow pointing far away), with a magnified inset showing $e^{-10^9}$ is a decimal with hundreds of millions of leading zeros.

Recall

Why $-10^9$ instead of literal $-\infty$ in code? ::: $e^{-\infty }$ can generate NaN; a large finite $-10^9$ gives $e^{-10^9}\approx 0$ (smaller than machine precision) while keeping arithmetic finite and stable.

---

Step 7 — Zooming out: mask, sample, advance, repeat

WHAT. Constrained generation is Steps 1–5 run in a loop. Generate one token, feed it back to the constraint machine to advance its state, recompute which tokens are now valid, rebuild the mask, and go again.

WHY a loop? Because "what is valid" changes with each token. After you emit {, the valid set is " or }. After a digit in a phone number, the valid set shifts to the next machine state. The mask is not fixed — it is recomputed at every step from the machine's current state.

PICTURE. A cycle: logits → add maskbias → softmax → sample token → machine advances → new valid set → back to logits. Two full turns are drawn, showing the valid set shrinking and shifting as ( then 5 are emitted for the phone-number regex \(\d.

---

The one-picture summary

The whole derivation on one canvas: raw logits (blue) → a gate that adds $0$ or $-\infty$ (the mask) → softmax → a probability pie with only valid slices → sample → the constraint machine steps forward and hands you the next legal set. Multiplication-by-$0$ is drawn crossed out to the side, with its two failure modes labelled.

Recall Feynman retelling — say it to a 12-year-old

Imagine the model shouting an eagerness number for every possible next word — that's the logit; big means keen, negative means "ugh, not that". To pick a word we turn those numbers into a fair spinner (softmax), where bigger numbers get bigger wedges — but every word still gets some wedge, even the disliked ones. Now suppose a rulebook says only certain words are allowed right now. The clumsy idea is "multiply the banned words' numbers by zero" — but zero is a perfectly good eagerness score, so banned words still get wedges, and if a word had a negative score, multiplying by zero actually raised it — you accidentally made the banned word more likely! The clean fix is to add a giant negative number ($-\infty$, or $-10^9$ in real code) to every banned word's score. Turning a spinner wedge's size uses $e^{(\cdot )}$, and $e^{-\infty }=0$ — so banned words get exactly zero wedge no matter what they started at, and the allowed words share the whole spinner among themselves. Do this every single step, letting the rulebook-machine tell you which words are legal next, and out comes text that is guaranteed to obey the rules — never a rejected retry, valid from the first character.

---

Related: contrast this proactive masking with reactive filtering in the parent main note; the softmax and sampling here connect to sampling strategies; content-level policy comes from RLHF; masks that hide rules can be probed by adversarial attacks; multiple constrained agents combine in multi-agent systems.