Decision Making II: POMDPs and Belief-Space Planning

Planning over beliefs instead of states: the alpha-vector value function, why exact solving explodes, and how sampled lookahead makes a robot pay to find out where it is.

Two doors, and a microphone that costs a dollar

Rusty is in the Hallway in front of two identical doors. Behind one is the charging dock. Behind the other is an open stairwell. The doors look the same, the floor looks the same, and the map is no help: this corridor is symmetric.

There is a microphone. Pressing it costs one unit of battery and returns a direction — left or right — that is correct 85% of the time. Opening the right door earns $+10$; opening the wrong one costs $-100$ and a trip to the repair bench.

That is the whole problem, and it is the oldest toy in the field: Kaelbling, Littman and Cassandra's tiger problem (1998), which we will use for every number in this chapter because every number in it can be checked by hand. Play it before reading further. The widget opens on the optimal pilot; take control with You play and try to beat it.

Three things are worth noticing, and each is a section of this chapter.

Sensing is an action, and it has a price. Listening does not move the robot and does not open anything. Its entire value is that it moves the belief. In Chapter 21's MDP there was no such action — every action was worth something because of where it took you. Here an action is worth something because of what it tells you, and the Bellman equation has to be able to say so.

The value function lives over the belief, and it is made of straight lines. The lower panel is the actual object this chapter is about: $V$ plotted against $b(\text{tiger-left})$. Each faint gray line is one $\alpha$-vector; the bold curve is their upper envelope. The policy is not stored anywhere — it is read off the envelope, one action per linear piece.

Certainty is worth money, and the shape of $V$ says how much. $V$ is convex. It is lowest in the middle, where the robot knows nothing, and highest at the ends, where it knows everything. The vertical gap between the chord and the curve is not a metaphor — it is the expected value of perfect information, in the same units as the reward. At $b = \tfrac12$ the tiger's converged numbers give $28.4028 - 19.3714 = 9.03$, so a free oracle would be worth just over nine points, and a microphone at one point per press is a bargain. That is why the optimal policy burns battery on presses that accomplish nothing physical.

Building intuition

Averaging over worlds is not planning under uncertainty

The tempting move — and the one almost every first implementation makes — is this: I do not know which world I am in, so let me solve each candidate world, then average the answers. Compute $Q^*(x, u)$ for the tiger-left world and the tiger-right world, weight by $b$, act greedily.

That is a real algorithm, it is called QMDP, and we will implement it. It is also structurally incapable of the behavior in the widget above, for a reason the draft of Probabilistic Robotics states flatly: "the planning problem in partially observable environment cannot be solved by considering all possible environments and averaging the solution."

The reason is that averaging happens before the max. In each individual world the robot knows where the tiger is, so listening is a waste of a battery unit; the microphone earns its keep only in the counterfactual where you might have been wrong. Average first and that counterfactual is gone. Switch the widget's pilot to QMDP and watch the envelope collapse from nine linear pieces to three — and look at the middle one. It is horizontal: QMDP assigns listening the same value $189$ at every belief, because under its assumption the fog lifts anyway. A flat piece is an action whose worth does not depend on what you know, which is precisely an action with no informational value.

Why $V$ is convex, in one paragraph and no algebra

Suppose someone offers you a choice. Option A: you are told, honestly, which of two belief states $b_1$ or $b_2$ you are in — a coin decides, with probability $\lambda$ and $1-\lambda$. Option B: you are told nothing, and you must act on the mixture $\lambda b_1 + (1-\lambda) b_2$.

Option A is worth $\lambda V(b_1) + (1-\lambda) V(b_2)$, because you get to run the best policy for whichever one came up. Option B is worth $V(\lambda b_1 + (1-\lambda)b_2)$, and whatever policy is best there was available under option A too. So

That is convexity, and it is the formal statement of information has non-negative value. The gap between the two sides at any belief is what the robot should be willing to pay to have its uncertainty resolved. Read the widget's envelope again with that in mind: the deeper the sag in the middle, the more the microphone is worth.

The mathematics

Notation

The POMDP tuple

A partially observable Markov decision process is Chapter 21's MDP with one thing added and one thing taken away:

Added: the observation set $\mathcal{Z}$ and the measurement model $p(z \mid x', u)$ — which is Chapter 10's object, now allowed to depend on which action you took, because "take a photograph" and "drive forward" do not return the same kind of reading. Taken away: the assumption that the agent is ever told $x$. It sees only $u_{1:t}$ and $z_{1:t}$, and starts from a prior $b_0$.

Everything else is inherited. In particular $r(x,u)$ is still Chapter 21's payoff, collected on taking $u$ in $x$, and $\gamma \in (0,1)$ still buys convergence.

The tiger, completely specified, is the instance every number below refers to:

The belief transition is the Bayes filter, wearing a new hat

Nothing new happens here at all, and that is the point worth making loudly. Given a belief, an action and an observation, the next belief is

which is Chapter 5's two lines — predict, then correct — with the integral become a sum. The normalizer is the evidence, and here it stops being housekeeping and becomes load-bearing, because it is the transition probability of the belief MDP:

Two consequences that shape everything downstream. First, the belief dynamics are deterministic given $(u, z)$: all the stochasticity of a POMDP sits in which observation arrives. Second, the belief MDP's branching factor is $|\mathcal{Z}|$, not $|\mathcal{X}|$ — a tree over action–observation histories, which is exactly the object POMCP builds later in this chapter.

Run the tiger numbers by hand. From $b(x_L) = \tfrac12$, hearing $z_L$:

A second, consistent $z_L$:

and one contradicting $z_R$ from there takes it straight back down. From $0.85$, a single $z_R$ returns the belief to exactly $\tfrac12$ — the two growls cancel, because the likelihood ratio is the reciprocal. That is the ladder the marker climbs in the widget above, and the whole optimal policy is a statement about where on that ladder you may stop.

The belief MDP

The value function is piecewise-linear and convex

This is the theorem that makes the chapter possible — Sondik's, published with Smallwood in 1973. Every exact POMDP algorithm since is a way of maintaining the object it describes.

The explosion, watched live

The count in Step 5 is the whole story. For the tiger, $|\Gamma_1| = 3$, and then

This is doubly exponential in the horizon, on a problem with two states. It is not a scaling problem to be solved with a bigger machine; it is a combinatorial one, and every practical method in this chapter exists because of this line.

Pruning rescues it, and by an enormous margin — but only because most of those vectors are never the maximum anywhere on the simplex. Turn the toggle off in the widget below and watch the counter run away while the picture stops being drawable.

For the record, here is what our solver actually produces on the tiger at $\gamma = 0.95$, accuracy $0.85$ — candidates generated versus vectors that survive:

Two honest observations. The candidate counts stay small only because each row is computed from the pruned previous row — that is the feedback loop that keeps exact value iteration alive at all. And the kept counts are not monotone: at $T = 4$ the minimal set is smaller than at $T = 3$. Nothing is wrong. The minimal representation of a value function has no obligation to grow, and a solver that assumes it does will over-prune or under-prune.

Pruning, and what our pruning misses

Given a candidate set $\Gamma$, the minimal set is $\{\alpha \in \Gamma : \exists b \in \Delta,\ \langle \alpha, b\rangle > \langle \alpha', b \rangle\ \forall \alpha' \ne \alpha\}$ — the vectors that own at least one witness point. Three tests, in increasing cost:

1. Duplicate merge. As value iteration converges the backup keeps re-deriving the same linear piece through different observation branches. Without a merge, $|\Gamma|$ grows without bound while $V$ stands still. Sort lexicographically and sweep: $O(n \log n)$.
2. Pointwise dominance. If $\alpha'(x) \ge \alpha(x)$ for every $x$, then $\alpha$ can be deleted. Free, exact, and it never removes a vector it should keep — but it misses vectors that are dominated only by combinations of others.
3. Witness test. $\alpha$ survives iff the linear program $\max_{b,\,\delta} \delta$ subject to $\langle \alpha - \alpha', b\rangle \ge \delta$ for all $\alpha' \ne \alpha$, $b \in \Delta$, has $\delta > 0$. This is exact, and it is one LP per candidate.

We implement 1 and 2 always. For two states we then do something better than an LP: with $b = (t, 1-t)$ every $\alpha$-vector is the line $\langle \alpha, b \rangle = \alpha(x_R) + (\alpha(x_L) - \alpha(x_R))\, t$, and the minimal set is exactly the upper envelope of a set of lines — a convex hull, computable exactly in $O(n \log n)$ with no numerical tolerance games. That is what draws the bold curve in both widgets, and it is why the thresholds quoted in this chapter are exact rather than sampled. For three or more states we fall back to a witness search: test the simplex corners, then a few thousand Dirichlet-sampled interior points.

QMDP, and exactly what it cannot see

The cheapest approximation is to keep only the first backup and stop. Assume that after one action the fog lifts entirely and the state becomes observable. Then the value of doing $u$ in belief $b$ is just the average, over states, of Chapter 21's $Q^*$:

This is an $\alpha$-vector set with exactly $|\mathcal{U}|$ members, for any horizon, and it costs one Chapter 21 solve. It is also an upper bound: $V_{\text{QMDP}}(b) \ge V^*(b)$, because it prices a relaxed problem in which someone tells you the state after one step, and more information cannot hurt. On the tiger the bound is spectacularly loose — $V_{\text{QMDP}}(\tfrac12) = 189$ against $V^*(\tfrac12) = 19.37$, a factor of ten — but it is sound everywhere and free, which is why it is the standard upper bound in DESPOT's and SARSOP's branch-and-bound. A bad estimator can still be a useful certificate.

Now the sharp statement of what QMDP gives up.

There is a subtler failure that the widget above is built to expose, and it matters more in practice. QMDP is not incapable of choosing the microphone in the tiger problem — listening also happens to be a cheap way of not dying, so it gets chosen for the wrong reason. What QMDP gets wrong is when to stop: it opens a door as soon as $b(x_L) \ge 0.9$, where the optimal policy waits for $0.9603$.

Work out where $0.9$ comes from, because it is a two-line calculation. Under full observability the optimal policy is "open the correct door", worth $V^* = 10 + \gamma V^*$, so $V^* = 200$ at $\gamma = 0.95$. Then $Q^*(x, \text{listen}) = -1 + 0.95(200) = 189$ for both states, while $Q^*(\cdot, \text{open}_R) = (10 + 190,\ -100 + 190) = (200, 90)$. Opening beats listening when $90 + 110\,t \ge 189$, i.e. $t \ge 0.9$ — and notice that the number $0.9$ contains no reference to the hearing accuracy at all. Drag the accuracy slider in the widget from $0.55$ to $0.99$ and QMDP's threshold does not move by one digit. That is Step 1 of the derivation, made visible.

PBVI: keep the value function only where the robot can get to

The exact backup maintains $V$ everywhere on the simplex. Point-based value iteration (Pineau, Gordon and Thrun, 2003) keeps it only at a finite set $B$ of belief points, and — this is the whole idea — keeps exactly one $\alpha$-vector per point:

Crucially you never build the cross-sum. For a fixed $b$, the best assignment $k(\cdot)$ is found one observation at a time — $k(z) = \arg\max_k \langle g^{u,z}_k, b\rangle$ — because the $z$-terms are independent. The backup therefore costs $O(|B|\,|\mathcal{U}|\,|\mathcal{Z}|\,|\Gamma|\,|\mathcal{X}|)$ and returns at most $|B|$ vectors. Doubly exponential becomes polynomial, and the price is that $\Gamma'$ is a lower bound on $V^*$: every $\alpha_b$ is the value of a real conditional plan, just not necessarily the best one somewhere else on the simplex.

The error bound is $\|V^B - V^*\|_\infty \le \dfrac{(r_{\max} - r_{\min})\,\epsilon_B}{(1-\gamma)^2}$, with $\epsilon_B = \max_{b' \in \Delta} \min_{b \in B} \|b - b'\|_1$ the density of $B$ in the simplex. Be honest about it: on the tiger with $r_{\max} - r_{\min} = 110$ and $\gamma = 0.95$ the prefactor is $44\,000$, so with our five belief points ($\epsilon_B \approx 0.35$) the bound reads "the error is at most $15\,400$", while the actual error at $b = \tfrac12$ is $2.62$. The bound proves convergence as $B$ densifies. It certifies nothing at any $|B|$ you would actually run.

What does matter is which points you pick, and that is PBVI's real contribution: expand $B$ along reachable beliefs, $B \leftarrow B \cup \{\tau(b,u,z)\}$, rather than gridding the simplex. Switch the Alpha Forge to PBVI mode and take the belief count down to three. With $B = \{(\tfrac12,\tfrac12), (1,0), (0,1)\}$ the envelope collapses onto QMDP's answer — threshold exactly $0.900$ — because the corners of the simplex cannot see that listening is worth anything at $0.9$. Add the reachable point $0.85$ and the threshold jumps to $0.960$; add its mirror $0.15$ and it settles at $0.958$, within $0.003$ of the exact $0.9603$. Five well-chosen points buy most of what the exact solver spends millions of vectors on. SARSOP (Kurniawati, Hsu and Lee, 2008) industrialized precisely this observation, by targeting beliefs reachable under near-optimal policies.

Online planning: POMCP searches histories, not states

Everything so far computes a policy for all beliefs, offline. The modern robotics answer is to give that up. At each timestep, plan only from the belief you are actually in, spend a fixed compute budget, act, and re-plan.

POMCP (Silver and Veness, 2010) is Monte-Carlo tree search over action–observation histories, and it fits this book unreasonably well because it needs two things you already built:

• A generative model $G$: a black box that, given $(x, u)$, samples $(x', z, r)$. That is the Chapter 4 simulator, verbatim. POMCP never sees a transition matrix, which is why it scales to state spaces you could not write one for.
• A particle set for the root belief. That is Chapter 8's object, and Chapter 12's MCL produces one every frame.

The mechanism: each simulation samples a state from the root particles, then walks down the tree picking actions by UCB1 — $\arg\max_u\, Q(h,u) + c\sqrt{\log N(h) / N(h,u)}$ — stepping the generative model at each node, and appending the sampled state to whichever child node the generated observation leads to. When it falls off the tree it runs a rollout policy to the horizon and backs the return up along the path.

The beautiful part is the belief representation. Nobody runs a Bayes filter inside the tree. The particles that happen to reach node $huz$ are, by construction, distributed according to $\tau(\dots\tau(b_0,u,z)\dots)$: the observation branching does the conditioning, and the surviving particles are the posterior. Sampling is the filter.

Two caveats, both inherited from Chapter 8 and both real. Particle deprivation gets worse with depth: a node three observations down may hold four particles, and its value estimate is noise. Particle deprivation gets worse on re-rooting: when you execute $u$ and observe $z$, the new root is node $huz$, whose particles are all you have — which is why practical implementations reinvigorate with noise, exactly as Augmented MCL does. And the UCB1 constant is not a tuning afterthought: set it too small in the widget above and both opening arms get exactly one pull, the unlucky one draws the tiger, and neither is ever tried again. The planner then listens forever on the strength of a single rollout.

DESPOT, in one page

POMCP's weakness is that the tree branches on every observation that happens to be sampled, so with many observations it becomes a bush of singleton nodes. DESPOT (Ye et al., 2017) fixes this with one idea: fix $K$ scenarios in advance.

A scenario $\phi = (x_0, \phi_1, \phi_2, \dots)$ is a start state plus a stream of random numbers. Determinize the generative model so that $(x', z, r) = G(x, u, \phi_t)$ is a function. Now a policy's outcome under scenario $\phi$ is deterministic, and the sparse tree contains only the $\le K$ observation branches that actually occur under the $K$ scenarios — the branching factor becomes $K$ instead of $|\mathcal{Z}|$, and the whole tree evaluates all $K$ scenarios at once.

Two consequences worth remembering. First, the value estimated on $K$ scenarios overfits, exactly as empirical risk does: a policy can be tailored to the sampled futures. DESPOT's regularized objective, $\max_\pi\, [\hat V_\phi(\pi) - \lambda |\pi|]$, penalizes policy size and comes with a regret bound in terms of the representation size of the optimal policy — the analogue of a generalization bound, and the reason the regularization is not an optional extra. Second, it is anytime and bounded: the search is guided by an upper bound (QMDP serves) and a lower bound (any default policy), and the gap between them at the root is a certificate you can stop on. It is a genuinely small amount of code once POMCP exists — which is why it is this chapter's stretch exercise rather than its main listing.

AMDP: compress the belief, then use Chapter 21 unchanged

For Rusty in the Apartment, none of the above applies directly: $\bel(x)$ over $\SEtwo$ is an infinite-dimensional object and $\mathcal{Z}$ is a LiDAR scan. The oldest robotics answer is also still one of the best: throw almost all of the belief away and keep two numbers.

Where I probably am, and how sure I am. Plan in that augmented space with Chapter 21's value iteration — nothing else changes — and you get the augmented MDP (Roy and Thrun, 1999; Thrun et al. §16.5). For a 2-D isotropic Gaussian belief the entropy coordinate collapses to a single position standard deviation: the differential entropy — the continuous analogue of the sum above, which may be negative, and only its differences matter here — is

so "minimize entropy" and "minimize $\sigma$" are the same instruction, and $\sigma$ has the advantage of being drawable as the width of a ribbon.

The transitions in the augmented space need $\sigma' = f(\sigma, x, u)$, and here Chapter 6 hands us the answer in one line of information form:

Prediction adds variance; correction adds information. The only genuinely new modelling object is $\nu(x)$, the localizability of a place: how much information one scan taken there delivers. We model it as $\nu(x) = \nu_{\max}\exp\!\big(-(d(x)/R)^2\big)$, where $d(x)$ is the distance to the nearest wall the robot can actually localize against and $R$ is the LiDAR range. A scan is informative when there is geometry inside it — and note that occupancy and information are two different maps, because a long featureless wall constrains distance-to-wall and nothing else, which is exactly the degeneracy Chapter 16's scan matcher suffers from.

The algorithms

This is Thrun et al.'s Table 16.1 with the pruning step promoted from a remark to line 8, and with the action tag kept on each vector so that a policy can be read off without a second pass.

Line 3 is the only place uncertainty enters the reward, and it is worth pausing on: the collision term is $\Pr[\|e\| > d]$ for a 2-D isotropic Gaussian error, which is a Rayleigh tail, $\exp(-d^2/2\sigma^2)$, with $d$ the clearance to the nearest wall. A robot that is uncertain is charged for being uncertain in proportion to how tight the space is — which is why the emergent behavior is not "always hug walls" but "hug walls where it pays".

A worked example you can check by hand

Everything in this section is doable on paper in about fifteen minutes, and every number is pinned by a test in the next section.

$\Gamma_1$ and $\Gamma_2$ for the tiger

$\Gamma_1$ is the immediate-reward set, written above: $(-1,-1)$, $(-100,10)$, $(10,-100)$.

For $\Gamma_2$ we need the backprojections. Under listen the transition is the identity, so $g^{\text{listen},z}_k(x) = p(z \mid x)\,\alpha^{(k)}(x)$ — no sum survives. Take the assignment "if I hear left, follow $\alpha^{\text{open}_R}$; if I hear right, follow $\alpha^{\text{listen}}$":

Under open$_R$ the transition resets to $(\tfrac12,\tfrac12)$ and the growl carries nothing, so every backprojection is $\tfrac14\big(\alpha^{(k)}(x_L) + \alpha^{(k)}(x_R)\big)$ regardless of $z$. With both branches following $\alpha^{\text{listen}} = (-1,-1)$, each backprojection is $\tfrac14(-2) = -\tfrac12$, and there are two observations to sum over:

Note what just happened: because opening resets the world, every assignment $k(\cdot)$ with the same total $\sum_z\big(\alpha^{(k(z))}(x_L)+\alpha^{(k(z))}(x_R)\big)$ gives the same vector. Nine assignments collapse to three distinct candidates before pruning even starts.

Grind through all $3 \cdot 3^2 = 27$ assignments and exactly five vectors survive pruning:

Their upper envelope has four breakpoints, and each is a two-line calculation. Where does "open right now" overtake "listen, then open right"?

and where does the do-nothing plan give way to it?

So the two-step policy is: open right above $0.975664$, listen below it, and by symmetry open left below $0.024336$.

The converged answer, and a chain that closes

Run the backup to convergence and the tiger's minimal set has $|\Gamma^*| = 9$ vectors and exactly three policy regions:

with values $V^*(\tfrac12) = 19.3714$, $V^*(0.85) = 21.4435$, $V^*(0.969799) = 25.0807$ and $V^*(1) = 28.4028$. Those four numbers are not independent, and checking that they close is the best possible test that the solver is right:

(The residual digit in the last two lines is rounding, not error: run the solver at full precision and the three identities close to six decimals. The book's test asserts them to $10^{-3}$. If you read $0.9611$ rather than $0.9603$ in the widget above, that is not a discrepancy either — it solves to horizon $20$ so that the accuracy slider stays interactive, and the last $0.0008$ of the threshold is carried by the discounted tail beyond step twenty.)

Read the second and third lines as sentences. From complete ignorance, the optimal thing to do is pay one unit, and you will find yourself at $0.85$. From $0.85$, pay one more unit; with probability $0.745$ the growl agrees and you land at $0.969799$, which is past the threshold, so you open; with probability $0.255$ it disagrees and you are back where you started. Listen, listen, open — and the number $0.960346$ is the entire reason it is two listens and not one or three.

Implementation in Rust

The crate is crates/ch22_pomdp. It depends on ch21_mdp (for QMDP's inner solve and for the augmented-MDP lab), on ch08_particles (for POMCP's root beliefs), and on nothing else that is not in the book's stack.

The model: dimensions as types

use nalgebra::{SMatrix, SVector};

/// A finite POMDP with `S` states, `A` actions and `Z` observations.
///
/// The dimensions are const generics because they are genuinely fixed by the
/// problem, and because it makes the compiler check the one thing that is easy
/// to get wrong: whether a matrix is indexed [x][x'] or [x'][x].
pub struct FinitePomdp<const S: usize, const A: usize, const Z: usize> {
    /// `t[u]` is row-stochastic: row `x`, column `x'` holds p(x' | x, u).
    pub t: [SMatrix<f64, S, S>; A],
    /// `o[u]` is row-stochastic: row `x'`, column `z` holds p(z | x', u).
    /// Note the *next* state: the observation follows the transition.
    pub o: [SMatrix<f64, S, Z>; A],
    /// r(x, u), with Chapter 21's convention — collected on taking u in x.
    pub r: SMatrix<f64, S, A>,
    pub gamma: f64,
}

pub type Belief<const S: usize> = SVector<f64, S>;

impl<const S: usize, const A: usize, const Z: usize> FinitePomdp<S, A, Z> {
    /// b̄(x') = Σ_x p(x' | x, u) b(x). Prediction: the step that loses information.
    ///
    /// The transpose is the whole content of "rows are `x`, columns are `x'`".
    pub fn predict(&self, b: &Belief<S>, u: usize) -> Belief<S> {
        self.t[u].transpose() * b
    }

    /// τ(b, u, z), together with the evidence p(z | b, u).
    ///
    /// The evidence is returned rather than discarded because in a POMDP it is
    /// not a diagnostic — it is the branching probability of the belief MDP,
    /// and the PWLC derivation turns on it cancelling against this normalizer.
    pub fn update(&self, b: &Belief<S>, u: usize, z: usize) -> (Belief<S>, f64) {
        let bar = self.predict(b, u);
        let mut un = bar.component_mul(&self.o[u].column(z).into_owned());
        let evidence = un.sum();
        if evidence > 0.0 {
            un /= evidence;
        }
        (un, evidence)
    }

    /// ρ(b, u) = Σ_x b(x) r(x, u). Linear in b — the load-bearing fact.
    pub fn reward(&self, b: &Belief<S>, u: usize) -> f64 {
        self.r.column(u).dot(b)
    }

    /// The underlying MDP, with the observation model **dropped on the floor**.
    ///
    /// This method is the QMDP indifference theorem, expressed as code: nothing
    /// downstream of here can possibly depend on how good the sensor is.
    pub fn underlying_mdp(&self) -> ch21_mdp::Mdp<A> { /* … */ }
}

pub const LISTEN: usize = 0;
pub const OPEN_LEFT: usize = 1;
pub const OPEN_RIGHT: usize = 2;

/// Kaelbling, Littman & Cassandra (1998), with this book's discount.
pub fn tiger(accuracy: f64, gamma: f64) -> FinitePomdp<2, 3, 2> {
    let a = accuracy;
    let stay = SMatrix::<f64, 2, 2>::identity();
    // Opening a door ends the round: the tiger is re-placed uniformly and the
    // growl that follows carries no information at all.
    let reset = SMatrix::<f64, 2, 2>::repeat(0.5);
    FinitePomdp {
        t: [stay, reset, reset],
        o: [SMatrix::<f64, 2, 2>::new(a, 1.0 - a, 1.0 - a, a), reset, reset],
        r: SMatrix::<f64, 2, 3>::new(
            -1.0, -100.0, 10.0, //  tiger-left:  listen, open-left, open-right
            -1.0, 10.0, -100.0, //  tiger-right: …
        ),
        gamma,
    }
}