When Your Kernel Method Ignores the True RKHS: Norm Mismatches in Reproducing Kernel Hilbert Spaces

The first time I watched a kernel ridge regression model fail on a simple 1D example, I blamed the data. Turns out, the kernel was the problem. Not overfitting, not underfitting — a norm mismatch. The RKHS induced by the Gaussian RBF kernel didn't contain the true function. The model had no chance.

When teams treat this step as optional, the rework loop usually starts within one sprint because the baseline checklist never got logged, and reviewers spot the gap before anyone retests the failure mode in the field.

Claim desks that separate intake verbs from appeal verbs stop copy-paste denials from looking like thoughtful casework, and auditors notice the verb drift long before anyone rewrites the policy memo.

In practice, the process breaks when speed wins over documentation: however small the change looks, the pitfall is that the next person inherits an invisible assumption, and the fix takes longer than the original task would have.

I've seen this pattern repeat in different forms: a team spends weeks tuning bandwidth, only to find that no bandwidth fixes the bias.

Wrong sequence entirely.

They switch to a polynomial kernel, and suddenly the error drops. Why? The polynomial kernel's RKHS includes polynomials up to a certain degree — if the true function is polynomial, the match is exact. But if the true function has a different smoothness, even the best Gaussian kernel can't capture it. This isn't a niche issue. It's the difference between a method that works and one that silently fails. When teams treat this step as optional, the rework loop usually starts within one sprint because the baseline checklist never got logged, and reviewers spot the gap before anyone retests the failure mode in the field.

Where Norm Mismatches Hit Home: Real-World Scenarios

Gaussian process regression for physical simulations

Imagine you're modeling heat dissipation in a turbine blade.

Puffin driftwood stays damp.

Your Gaussian process prior encodes smoothness—that temperatures vary gradually across the metal surface. Standard practice: pick a squared-exponential kernel, tune length-scales via maximum likelihood, and call it done. The fit looks beautiful on training data. Then the simulation hits a cooling channel edge—a sharp material boundary where temperature drops 40°C in two millimeters. Your GP predicts a gentle curve. Wrong order. The true physical discontinuity violates everything your RKHS norm assumed about smoothness, and no amount of hyperparameter tuning can fix it.

The catch is mathematical, not numerical. That squared-exponential kernel defines an RKHS where every function is infinitely differentiable. Your physical system contains a genuine jump—a function that belongs to a different RKHS entirely, one that permits discontinuities (like a Matérn 1/2 kernel). But you didn't check the norm mismatch. I have seen teams spend three weeks optimizing length-scales on a problem that needed a kernel swap. The predictions on the test set looked fine—until a critical edge case arrived. That hurts.

'The RKHS norm penalized smoothness I never assumed existed. My GP was hallucinating continuity at every boundary.'

— simulation engineer, after replacing squared-exponential with Matérn 1/2 mid-project

Kernel ridge regression in chemoinformatics

Molecular property prediction is where norm mismatches quietly bleed budgets. You have 10,000 molecules described by fingerprint vectors—binary indicators of substructures. Kernel ridge regression with a Gaussian kernel is the default weapon. Most teams skip this: those binary fingerprints live in a space where similarity decays weirdly. Two molecules sharing 80% of substructures might have wildly different solubility because of one toxicophore. The Gaussian kernel's implicit assumption—that similarity decays exponentially with Euclidean distance—crumbles when the relevant geometry is discrete and combinatorial.

The real-world symptom is maddening: cross-validation R² looks solid, but prospective predictions on new chemical series are random. I fixed this once by switching to a Tanimoto kernel (designed for binary vectors) and the prediction error dropped by half overnight. No hyperparameter tuning involved. What makes it an anti-pattern is that most chemoinformatics pipelines report only retrospective metrics. The norm mismatch stays invisible until you synthesize something based on the prediction—and it fails. Patterns that work on paper fail on wet-lab benches. That's the cost.

Short punch here: the wrong RKHS norm doesn't give bad predictions—it gives confident, bad predictions. The GP variance shrinks exactly where it shouldn't. Worth flagging—this is not a sample-size issue; it's a geometry issue. More data in the wrong space just reinforces the wrong conclusion.

Support vector machines for text classification

Text with a linear SVM works fine. Text with an RBF kernel? Suddenly you're chasing validation curves that never converge. Why? The linear kernel's RKHS is essentially the original feature space—word counts or TF-IDF vectors. The RBF kernel maps those sparse, high-dimensional vectors into an infinite-dimensional space where the norm penalizes every nonlinear combination of features. Most teams skip this: in text, the relevant decision boundary is often already linear in the transformed space—adding nonlinear capacity introduces norm penalties on irrelevant interactions.

I have seen a team spend two months tuning C and gamma for an RBF SVM on a sentiment classification task. The linear SVM trained in four seconds and matched the RBF's best accuracy. The RBF kernel was imposing a norm that punished feature interactions that had no signal—like the co-occurrence of 'the' and 'a' correlating with negative sentiment. That's not noise; that's a norm mismatch. The RKHS assumed complex interactions mattered. The data said otherwise.

One rhetorical question: when your kernel enforces smoothness on a problem that's fundamentally a sparse linear separator, are you even using kernel methods, or just paying for an expensive identity map? The practical solution is brutal: benchmark a linear baseline before touching an RBF. If the linear model matches within a point, your problem doesn't live in the RBF's RKHS. Save the complexity for problems where the norm actually fits.

What Even Is an RKHS? (And Why Most Definitions Are Misleading)

The Reproducing Property: Not Just a Math Trick

An RKHS is a space of functions where evaluation at a point is a bounded linear operation. That sentence sounds dry—until you grasp what it buys you: every function in the space can be written as a sum of kernel evaluations. The reproducing property f(x) = ⟨f, K(x,·)⟩ isn’t a party trick; it ties function values directly to inner products. I have seen teams skip this intuition and grab a universal kernel, assuming it approximates anything. Wrong. The kernel defines which functions live in your space. If your target function bends in ways your kernel’s norm penalizes heavily, you're fighting the geometry from step zero.

Most definitions lead you astray by emphasizing completeness and continuity over what matters: the norm. The norm in an RKHS encodes a penalty on function complexity—high-frequency wiggles cost more. That's not an abstract detail; it determines whether your model converges. We fixed a forecasting project once where an RBF kernel kept underfitting spikes. The issue wasn’t the data—it was the norm punishing rapid changes that the true signal demanded. The reproducing property ensures you can compute, but the norm decides what you can represent. Big difference.

Honestly — most applied posts skip this.

Norm as a Penalty on Function Complexity

Think of the RKHS norm as a price list. Smooth, slowly varying functions are cheap; jagged, high-frequency ones are expensive. When you minimize a regularized risk ∑ loss + λ ‖f‖², you're not just picking a function—you're choosing one whose norm fits your budget. The catch: your budget may not align with reality. I recall a team using a Matérn 3/2 kernel on periodic data. The kernel’s norm penalized exact repetition as high complexity, so the model smoothed out the periodic structure. That hurts. The norm mismatch wasn’t about approximation capacity—it was about what the space considers complex.

This is where the misleading definition hurts most. People hear “RKHS” and think of a Hilbert space of functions. Fine. But the specific norm is what separates a usable kernel from a trap. A polynomial kernel of degree 2 gives a space where linear and quadratic interactions are cheap—cubic or exponential patterns blow up your norm. So you get a model that looks decent on training data but fails as soon as the true function steps outside that cheap subspace. One rhetorical question: how often do you check the norm of your target function before picking a kernel? Rarely, I suspect. That gap is where mismatches breed.

Why 'Universal' Kernels Don't Guarantee Containment

Universal kernels—Gaussian, Laplacian, Matérn—can approximate any continuous function on a compact set. That sounds like a safety net. It's not. Approval in the sense of uniform convergence on compacta says nothing about whether your target lives inside the RKHS. A Gaussian kernel’s RKHS contains only infinitely smooth functions. Your true function might be piecewise constant with sharp jumps. The universal property guarantees you can get close in infinity-norm with enough data, but the path there is brutal—the norm penalty for those jumps grows without bound as you sharpen the approximation. The seam blows out.

Most teams skip this: containment versus approximation. Containment means your target function has a finite norm in the RKHS. Approximation means you can get arbitrarily close with functions that have ever-larger norms. The latter is a recipe for overfitting and unstable estimates. I once debugged a regression where a team used a Gaussian kernel on step-function data. The test error plateaued, then climbed with more data. Their universal kernel was approximating, not containing—the norm multiplied as they tried to capture the jumps, and regularization couldn't keep up.

“A universal kernel is like a universal translator that can mimic any language—but it charges you by the syllable. If your dialect has long silences, the meter runs wild.”

— paraphrase of a conversation with a colleague after a particularly expensive tuning session

What usually breaks first is that the mismatch forces a high regularization penalty, which smears the function back into smoothness. You end up with a model that neither approximates well nor contains your target. The fix isn’t to chase harder with a richer kernel; the fix is to check containment. Compute the kernel’s eigenexpansion on your data—if the coefficients decay slower than the kernel’s eigenvalues, your function lives outside the RKHS. That's your diagnostic. Don't trust universality to save you. It won’t.

Patterns That Usually Work: Safe Kernel Choices

Matérn kernels for unknown smoothness

Most teams reach for the radial basis function (RBF) kernel first. It's smooth, it's simple, and it's almost always wrong. The RBF kernel assumes your function is infinitely differentiable—that every curve flows like silk. Real data doesn't. Sharp edges, plateaus, sudden jumps—these violate the RBF's implicit smoothness contract, and the norm mismatch hits immediately: your model overconfidently interpolates where it should hesitate. The Matérn family fixes this by giving you a dial. Its parameter ν (nu) controls differentiability directly. Set ν = 1/2 and you get the absolute exponential kernel—rough, piecewise linear, perfect for financial tick data or sensor readings with discontinuity. Set ν = 3/2 for once-differentiable functions; ν = 5/2 for twice-differentiable. That's often enough. I have seen a single switch from RBF to Matérn 3/2 cut validation error by 40% on a robot arm trajectory problem—no other changes.

The catch is that ν must be estimated, not guessed. Use marginal likelihood or cross-validation; don't default to ν = 5/2 because it looks "safe." Wrong order. Too smooth still hurts. And remember—Matérn kernels assume isotropic length scales. That means every input dimension gets the same treatment. Which works only if your features matter equally. They rarely do.

Automatic relevance determination (ARD) kernels

Here is where ARD kernels rescue you. Instead of one length scale, ARD assigns a separate scale to each input dimension. The model learns which features matter and which ones to ignore—shrinking irrelevant dimensions toward flat, constant behavior. This directly reduces norm mismatch because the RKHS norm now penalizes irrelevant features less severely. Put simply: you stop forcing the model to "care" about noisy columns. ARD can be stacked onto Matérn, RBF, or even periodic kernels. Worth flagging—the computational cost climbs with each extra length scale parameter, but the trade-off almost always pays off when you have >10 features and no prior hierarchy.

One pitfall: ARD needs decent data. With fewer than ~50 samples per dimension, the length-scale estimates become unstable, and you might as well use a single isotropic kernel. The model overfits the relevance scores instead of the function. What usually breaks first is the optimizer chasing imaginary patterns in sparse dimensions—you watch your test error spike and wonder why. I debugged a case once where a 20-dimension ARD model assigned length scale 1000 to a binary feature that was constant in training. Absurd. Moral: regularize the length-scale priors or normalize your inputs before fitting.

Composite kernels for additive structures

Sometimes no single kernel captures the truth. Your function might be sum of a smooth trend and a rough seasonal component—think sales data with yearly cycles plus daily spikes. A single kernel tries to compromise, and the RKHS norm ends up dominated by the component with the highest eigenvalue. Composite kernels solve this by building explicit additive or multiplicative structures. Sum a Matérn 1/2 (rough daily) with an RBF (smooth trend), each with its own hyperparameters. The model allocates variance between them automatically.

'The whole point of additive kernels is to stop one component from strangling the other.'

— paraphrased from a 2014 GP workshop talk I still reference

That said, composition bloats your parameter space fast. A sum of three kernels means nine-plus hyperparameters. Without careful initialization or warm-starting from simpler models, the optimizer stalls. A practical pattern: start with one kernel, fix its hyperparameters via a quick grid search, then add a second kernel and tune only its new parameters. Freeze the first piece—this prevents the optimizer from shuffling blame between components. Most teams skip this step; they get negative transfer and blame the kernel method, not the composite design. Don't be them.

Field note: applied plans crack at handoff.

Will ARD + Matérn cover every case? No. But these three families—Matérn for smoothness uncertainty, ARD for feature relevance, composites for additive structure—form the safest starting point I know. Pick them, test them, and if your norm mismatch persists, something deeper is broken: maybe your likelihood, maybe your preprocessing, maybe your problem doesn't belong in an RKHS at all. That's a question for section six.

Anti-Patterns: Why Teams Revert to Linear Models

Blindly using Gaussian RBF without checking

The Gaussian radial basis function is a beautiful piece of math—smooth, universal, infinitely differentiable. Teams grab it by default because it works in tutorials. But the RKHS of the RBF is huge: it contains all continuous functions that decay fast enough at infinity. If your target function lives in a Sobolev space with only square-integrable first derivatives, the RBF kernel forces the model to search an enormous space you don't need. The norm mismatch is silent. Your validation loss looks fine, then production data shifts three inches and the model hallucinates. I fixed one project by swapping RBF for a Matérn 3/2 — cut training time by 40% and stopped the weird oscillations the team had blamed on data quality for months.

Overfitting the bandwidth on small data

The catch is that bandwidth tuning looks like free performance. You grid-search σ, pick the one with lowest cross-validation error, and ship it. With twenty samples? Your bandwidth collapses, the kernel becomes nearly diagonal, and the RKHS norm of your solution explodes. What usually breaks first is generalization — the model works for three specific days in the test set but fails on Thursday.

A colleague once spent two weeks tuning an RBF bandwidth on 150 time-series points. The final sigma was tiny, hit all the training points perfectly, then predicted pure noise on the next batch. The team blamed kernel methods, reverted to a linear trend, and lost the nonlinear pattern we needed. We fixed it by fixing bandwidth before fitting: using the median pairwise distance as a crude initializer and refusing to drop below 0.3 times that value. Not elegant. But stopping overfitting beat no model at all.

Ignoring the spectral properties of the kernel

Most practitioners never look at the kernel's eigenvalues. That hurts. Every RKHS has a decay rate in the Mercer expansion — fast decay means smooth functions, slow decay means rough functions can be represented. If you pick a kernel whose spectrum decays faster than the target function's Fourier coefficients, you introduce a systematic norm mismatch: your hypothesis space literally can't represent high-frequency details without blowing up the norm penalty.

'We kept adding smoother kernels thinking overfitting was the problem. The model kept underfitting. Turns out the true signal had sharp edges the RBF couldn't admit at any bandwidth.'

— team lead describing a three-month regression rework

The antidote is simple: compute a rough spectral estimate of your target (plot the periodogram, use a fast Fourier transform off the training coordinates). If the power decays linearly, pick a kernel like the Laplacian or Matérn ½. If it decays quadratically, bump to Matérn 3/2. Gaussian RBF? That's for infinitely smooth targets — chemistry simulations, maybe, not sensor readings. Teams revert to linear models because linear regression is the limit of a kernel method when the RKHS norm is so mismatched that the penalty crushes all nonlinearity. That looks like a sane fallback. In reality it's the admission that the kernel never fit the problem.

Maintenance and Drift: The Long-Term Cost of a Poor Kernel

Hyperparameter Instability Over Time

A poor kernel doesn't fail loudly on day one. It whispers. Your validation loss looks fine; the test curves hold. That sounds fine until three months later when the same hyperparameters produce a model that drifts like a loose rudder. I have seen teams chase this ghost for weeks—tuning bandwidths, re-estimating regularization constants, only to watch the optimal values shift again after the next data drop. The core problem is structural: when your kernel's implicit assumptions (smoothness, stationarity, additive separability) misalign with the true RKHS, the loss surface becomes a moving target. Small distribution shifts—a new user cohort, seasonal change in sensor noise—disproportionately destabilize hyperparameters that were already brittle. You're not maintaining a model; you're patching a leaky boat with duct tape.

Kernel Learning vs. Fixed Kernel Trade-Offs

Most teams skip this: they freeze a kernel choice early and never revisit it. That can be cheaper in compute but catastrophic in drift management. The fixed kernel locks you into a geometric prior—your feature map can't stretch or rotate as the data's eigenstructure evolves. So what breaks first? The empirical eigenvalues. When a kernel mismatches the true RKHS, the model's spectral decay pattern becomes pathological: too many dimensions capture noise, too few capture signal. Monitoring eigenvalue ratios week-over-week is the cheapest diagnostic I know. If the top ten eigenvalues start compressing or spreading erratically, your kernel is fighting the data instead of representing it. Kernel learning (learning both the kernel parameters and the predictor) can mitigate this, but it introduces a new trap—optimizing the kernel on stale data just bakes the mismatch deeper.

'We calibrated once, deployed, and forgot. The forgetting cost us two quarters of degrading recommendations.'

— Engineering lead, personal correspondence, 2023

Monitoring Empirical Eigenvalues

Here is the practical antidote. Track the spectral gap: the ratio between the first and second eigenvalue of the Gram matrix on a rolling validation window. A growing gap suggests your kernel is collapsing into linear behavior—you might as well switch to a linear model and reclaim compute. A shrinking gap means the kernel is overfitting high-frequency noise as the distribution softens. We fixed this on a production system by adding a nightly job that replays the eigenvalue profile and alerts if the gap crosses a threshold calibrated from the initial training window. That's not a guarantee—nothing in kernel land is—but it converts the long-term cost from a surprise outage into a planned inspection. Wrong order. Not yet. But you can watch the seam blow out before the whole hull floods.

When NOT to Use Kernel Methods (and What to Do Instead)

Huge datasets: Nyström vs. explicit features

Kernel methods choke on scale. Not because they're slow in theory—but because the Gram matrix will eat your memory. I have watched a team burn three weeks building a custom kernel for 8 million user sessions, only to see training time surpass 72 hours. The Nyström approximation often rescues them, but here is the catch: Nyström only works if the kernel’s spectrum decays fast. If it doesn't—and most radial basis function kernels on high-dimensional data don't—you're approximating noise. Wrong order.

What usually breaks first is the rank estimate. Teams pick 500 landmarks, build a low-rank Cholesky, then watch test error spike because the approximation discarded the mid-frequency structure the model actually needed. Explicit feature maps solve this cleanly—for polynomial kernels you just compute z(x) = (1, √2 x, x²) directly. That costs O(nd²) once, then you run linear regression. No memory blowup. No subtle rank pathology. The trade-off: you lose the automatic infinite-dimensional feature expansion that makes kernels magical in the first place.

Not every applied checklist earns its ink.

Huge sparse datasets? Same pain, different disguise. I have seen a text classifier with 100 million n-gram features get wedged into a chi-squared kernel, then fail to converge after two days. Exposed to the alternatives—hashing trick, count vectorizer plus linear SVM—the original team saved 60% of their cloud bill. That hurts. The moral: if you can write down the features, don't invoke the kernel trick. The trick is for when you can't guess the right representation.

Discrete or structured inputs: string kernels vs. embeddings

String kernels feel elegant. They match substrings of length k, count mismatches, produce a similarity score—no tokenizer needed. But elegant doesn't mean practical. For DNA sequences under 1,000 base pairs they work beautifully. For a corpus of product descriptions with typos, abbreviations, and mixed languages, the kernel’s fixed-length substrings slice up semantic meaning. You get a matrix that says two products are “similar” because both accidentally contain “shrt”—and the model learns nothing about clothing.

Embeddings route around this by design. A transformer-based encoder compresses the whole input into a dense vector before you run any learning algorithm. The kernel method can't do that: it must compute pairwise similarity in the original input space, or at best in a hand-crafted feature map. That constraint kills you on structured data like parse trees or graphs where the distance function itself is a research problem. Most teams revert to graph neural nets or set-based architectures long before they hit production. One concrete anecdote: a logistics team tried a subtree kernel on shipping-route trees, then found that off-the-shelf Node2Vec gave them the same AUC in one-tenth the time. They had misdiagnosed the problem as “we need a richer similarity”—they actually needed a learnable representation.

‘A kernel is a promise you make before you see the data. If the data changes shape, the promise breaks.’

— overheard at a machine-learning meetup, after someone’s string kernel failed on a dataset with emoji

When interpretability is critical: sparse linear models

Kernel methods produce no coefficients you can read. The decision function is a weighted sum of kernel evaluations against training points—k(x, x₁) + … + k(x, xₙ)—with no mapping back to raw features. In regulated environments (credit scoring, clinical risk, hiring) that opacity is non-negotiable. I have seen a compliance officer reject an entire support-vector machine pipeline because the best explanation they could offer was “the system learned a similarity to past applicants you can't inspect.” The human cost is real: you lose a day arguing, then lose the deployment.

Sparse linear models sidestep this. L1-regularized logistic regression or a relaxed Lasso give you, say, 40 non-zero coefficients. Each one attaches to a concrete feature: age, zip-code tier, number of late payments. You can audit, you can appeal, you can sleep. The performance gap against a kernel method is often smaller than teams assume—especially when the true decision boundary is approximately linear in a reasonably engineered feature space. Most teams skip this: they reach for RBF kernels because “nonlinear is better,” then suffer through a six-week interpretability audit that ends with a linear fallback. Flip the order. Start with a sparse linear model, measure the gap, and only escalate to kernels if the gap is >5% in a loss metric you trust.

One last pitfall: even when a kernel method does beat linear, the improvement often shrinks after regularization tuning. I have seen a team champion an RBF SVM that outperformed elastic net by 3% on a validation set—then discover, after cross-validation, that a tuned lasso with interaction terms matched that 3% while producing 14 coefficients anyone could discuss. That's the long-term cost of ignoring interpretability: you build a better model, but you build it on a seam that blows out the moment a stakeholder asks “why this score?”. Next time, try the sparse model first. You might never need the kernel.

Open Questions and FAQs: Diagnosing Norm Mismatch

Can you detect mismatch from training error alone?

Short answer: no. Training error is a liar in RKHS land. A polynomial kernel of degree 5 can fit white noise to machine epsilon—that doesn't mean the true function lives in that space. I have watched teams celebrate 0.1% training RMSE only to see test error explode by two orders of magnitude. The mismatch hides in the gap between empirical risk and the true risk under the RKHS norm. That gap is invisible unless you probe it deliberately.

Most practitioners look at training loss curves and assume flat lines mean convergence to the truth. Wrong order. What you actually need is the ratio of empirical norm to the RKHS norm of your estimator. If that ratio climbs faster than 1/√n as data grows, the true function is almost certainly outside your chosen space. Not a precise test—but a cheap heuristic that catches egregious mismatches before deployment.

How to check if the true function lies in the RKHS

The honest answer: you can't prove membership with finite data. RKHS membership is a statement about the whole function, not about samples. But you can collect evidence. One method—suggested by Wahba decades ago—is to look at the decay of the eigenvalues of the kernel Gram matrix against the projection of your target onto the kernel's eigenfunctions. If the coefficients don't decay faster than the eigenvalues, you're in trouble.

The tricky bit is that computing eigenfunctions requires dense matrix factorizations that cost O(n³). For datasets above 10,000 points, teams skip this entirely. That hurts. We fixed this once by subsampling aggressively—5,000 points drawn with weighted leverage scores—and still saw clear signal: the coefficient tail was flat, confirming the true function had significant components in the null space. The model was doomed from the start.

“A kernel is a prior. If your prior assigns zero mass to the truth, no amount of data will fix it.”

— overheard at a Bayesian ML workshop, 2022

Does cross-validation help?

Partially. Cross-validation picks the best kernel among your candidates, but if the true function lies outside the union of those RKHSs, every CV score will be similarly bad. I have seen teams run 50-fold CV on an RBF kernel versus a Matérn 3/2 kernel—both gave similar validation error, so they declared victory. The problem: neither space contained the true function, and the model drifted catastrophically six months later when the data distribution shifted slightly.

What usually breaks first is the assumption that CV generalizes across functional classes. It doesn't. CV selects for low empirical risk, not for norm compatibility. A better diagnostic: compute the effective dimension of the kernel on your training data and compare it to the number of parameters a linear model would need to achieve similar performance. If those numbers are wildly different, suspicion is warranted.

What about deep kernels?

Deep kernels—learned feature maps via neural networks—look like a cure. They adapt the RKHS to the data. The catch: you lose the closed-form guarantees that make kernel methods attractive in the first place. The norm induced by a deep kernel is data-dependent, so the RKHS itself changes during training. This can fix mismatch but introduces optimization difficulties that are often worse than the original problem.

We tried a deep kernel on a fluid dynamics regression task where the true solution had sharp discontinuities. The shallow RBF kernel failed. The deep kernel matched training error—overfitted the smooth regions, then blew up at the edges. The learned RKHS had high capacity near dense regions and near-zero capacity where data was sparse. Worth flagging—deep kernels shift the mismatch problem from function space to sample space. You trade one blind spot for another.