Small Group Tutorials

Here to help students catch up, keep up, and move ahead. Book a consultation here.

How Gauss–Hermite Quadrature Algorithms Price Gaussian Financial Expectations: Hermite Nodes, Normal-Weight Scaling, Tensor Rules, Tail Error and Dimension Failure

Three students in school uniforms work through open books at a classroom table, with textbooks and stationery nearby and study notes on the whiteboard behind them.

Reader question: If a pricing or risk calculation is an expectation over one or a few Gaussian factors, do we always need Monte Carlo simulation, or can carefully chosen deterministic nodes integrate the expectation much faster?

Gauss–Hermite quadrature is designed exactly for integrals with Gaussian-type weights. Its nodes are the roots of Hermite polynomials, and its weights are chosen so that an n-point rule integrates weighted polynomials up to degree 2n−1 exactly. For smooth low-dimensional financial expectations, that can produce high accuracy with tens of function evaluations rather than millions of random paths.

This article owns one precise computational job: deterministic Gaussian-weight quadrature for low-dimensional financial expectations and conditional pricing integrals. It does not own Monte Carlo simulation, high-dimensional Smolyak sparse grids, Fourier inversion or a particular stochastic financial model.

This is public mathematical and computational education. It is not financial advice or a claim that Gauss–Hermite quadrature dominates Monte Carlo in high dimension, discontinuous payoffs or heavy-tailed/non-Gaussian problems.

1. Start with a Gaussian expectation

Let Z ~ N(0,1). We want:

E[g(Z)] = (1/√(2π)) ∫−∞∞ g(z)e−z²/2 dz.

This form appears whenever a model can be conditioned so that the remaining uncertainty is Gaussian.

Examples include:

  • lognormal terminal prices;
  • Gaussian short-rate factors;
  • conditional stochastic-volatility pricing;
  • latent Gaussian credit factors;
  • small-dimensional correlated-factor expectations.

2. Physicists’ Gauss–Hermite rule

The classical rule is built for:

∫−∞∞ e−x² f(x) dx.

With n nodes xi (roots of the nth Hermite polynomial) and positive weights wi:

∫ e−x² f(x) dx ≈ Σ wi f(xi).

The rule is exact when f is a polynomial of degree at most 2n−1.

3. Convert a standard-normal expectation correctly

Set:

z = √2 x.

Then:

E[g(Z)] = (1/√π) ∫ e−x² g(√2x) dx.

Therefore:

E[g(Z)] ≈ (1/√π) Σ wi g(√2 xi).

The √2 inside g and 1/√π outside are essential.

4. Probabilists’/statisticians’ convention

Some libraries instead use Hermite polynomials orthogonal under:

e−x²/2.

For example, SciPy’s roots_hermitenorm produces nodes and weights for that weight function.

The expectation then uses:

E[g(Z)] ≈ (1/√(2π)) Σ wi g(xi).

Falsifier: never mix node/weight conventions. A rule can look numerically smooth while being globally mis-scaled.

5. The simplest unit tests

Before pricing anything, verify moments:

E[1] = 1,

E[Z] = 0,

E[Z²] = 1,

E[Z⁴] = 3.

An n-point Gauss–Hermite rule should reproduce sufficiently low-order polynomial moments to floating-point precision when the scaling convention is correct.

6. Why Gaussian quadrature is so efficient

A generic equally spaced integration rule spends points without using the known weight function.

Gauss–Hermite chooses nodes where the Gaussian mass and orthogonal-polynomial structure make them maximally informative for polynomial exactness.

With n function evaluations, Gaussian quadrature achieves polynomial exactness through degree 2n−1—the optimal degree for an n-node rule under standard conditions.

7. Black–Scholes as a validation example

Under risk-neutral Black–Scholes:

ST = S0 exp[(r−q−½σ²)T + σ√T Z].

A European call price is:

C = e−rTE[(ST−K)+].

Gauss–Hermite can approximate this expectation directly.

Because the analytic Black–Scholes formula is known, this is an excellent quadrature validation benchmark.

8. Why a call payoff is not perfectly smooth

The call payoff has a kink at ST = K.

In Z-space, that becomes a kink at one normal threshold.

Polynomial-based quadrature still converges, but not as spectacularly as it does for entire analytic integrands.

Diagnostic: compare convergence for a smooth payoff and a digital payoff to see how non-smoothness degrades the rule.

9. Digital options are a stress test

A digital payoff:

1{ST > K}

is discontinuous.

Gauss nodes can jump from “below threshold” to “above threshold” as order changes, producing non-monotone convergence.

Falsifier: if a discontinuous payoff is central, compare against analytic probabilities, adaptive integration, conditional smoothing or another method rather than trusting one quadrature order.

10. Deep tail payoffs are another stress test

Gauss–Hermite nodes concentrate where the Gaussian weight is important globally.

A deep-out-of-the-money option may derive nearly all value from a far tail where only the outermost quadrature nodes contribute.

Low-order rules can therefore severely underresolve rare-event value.

Diagnostic: increase n and track the contribution of the largest-magnitude nodes separately.

11. A conditional-expectation use case

Suppose a complex model can be conditioned on one state V so that conditional on V the terminal asset distribution is Gaussian/lognormal.

Then:

Price = EV[ConditionalPrice(V)].

If V itself can be transformed to a near-Gaussian one-dimensional factor, Gauss–Hermite can integrate the outer expectation deterministically.

This “condition first, quadrature second” design is often more efficient than direct multidimensional integration.

12. Correlated Gaussian factors

Let Z ~ N(0,Σ).

If Σ = LLT is a Cholesky factorisation and X ~ N(0,I), then:

Z = LX.

A d-dimensional Gaussian expectation becomes an expectation over independent standard-normal coordinates X1,…,Xd.

A tensor-product Gauss–Hermite rule can then be constructed.

13. Tensor-product explosion

If each dimension uses n nodes, a d-dimensional tensor rule uses:

nd

function evaluations.

For n = 20:

  • d=1 → 20;
  • d=2 → 400;
  • d=5 → 3.2 million;
  • d=10 → about 10 trillion.

This is why ordinary Gauss–Hermite is primarily a low-dimensional tool.

14. Effective dimension can be much smaller than nominal dimension

Principal-component rotation can concentrate most Gaussian variance into a few directions.

If the payoff is also mostly sensitive to those directions, a reduced-factor quadrature can work even when the original covariance matrix is large.

Falsifier: verify omitted-factor sensitivity rather than assuming small eigenvalues imply small pricing impact.

15. Connection to Smolyak sparse grids

Smolyak sparse-grid algorithms reduce the tensor explosion by combining selected low-order tensor components rather than taking every full-grid combination.

Gauss–Hermite nodes can serve as one-dimensional building blocks inside sparse Gaussian quadrature constructions, although nested-node availability and implementation details matter.

16. Node computation via Golub–Welsch

Gauss nodes and weights can be computed from the three-term recurrence of orthogonal polynomials.

The Golub–Welsch algorithm builds a symmetric tridiagonal Jacobi matrix:

  • its eigenvalues are the quadrature nodes;
  • squared first components of eigenvectors determine weights after normalisation.

This avoids unstable direct root-finding on high-degree polynomial coefficients.

17. Use trusted node/weight libraries

Modern scientific libraries implement stable algorithms and distinguish the two Hermite conventions.

For example, SciPy’s statistician-weight implementation documents:

  • weight e−x²/2;
  • degree 2n−1 exactness;
  • modified Golub–Welsch for moderate n;
  • asymptotic methods for very large n.

Recomputing roots from polynomial coefficients is rarely justified in production finance code.

18. Inputs and outputs

Inputs can include:

  • quadrature order n;
  • Hermite convention;
  • mean/covariance transformation;
  • payoff/conditional-pricing function;
  • dimension d;
  • factor-reduction/rotation rule;
  • model parameters;
  • target error tolerance;
  • benchmark method.

Outputs can include:

  • price/expectation estimate;
  • node/weight set;
  • order-convergence table;
  • tail-node contribution diagnostics;
  • dimension/factor sensitivity;
  • moment-test residuals;
  • comparison with analytic/Monte Carlo values;
  • runtime/function-evaluation count.

19. Evidence polarity

Evidence for confidence includes:

  • normal moments reproduce exactly at expected degree;
  • known analytic prices match as n increases;
  • successive quadrature orders converge rapidly;
  • tail-node contributions stabilise;
  • factor rotation/reduction preserves benchmark prices;
  • independent physicist/statistician implementations agree after correct scaling;
  • results outperform Monte Carlo at equal error for low-dimensional smooth problems.

Evidence against confidence includes:

  • moment tests fail;
  • results shift under node convention;
  • digital/deep-tail prices oscillate with n;
  • outermost nodes dominate unstable estimates;
  • tensor node count explodes;
  • correlated-factor transform is ill-conditioned;
  • factor reduction changes price materially.

20. Counterexample: physicist/statistician mismatch

Take physicists’ nodes and forget the √2 transformation for a standard normal.

The rule integrates the wrong variance distribution.

Falsifier: E[Z²] will fail the unit test immediately.

21. Counterexample: deep-OTM digital

A digital pays only when Z > 4.

A low-order rule may have no node in the relevant tail region.

The computed value can be zero even though the true Gaussian tail probability is positive.

Falsifier: compare with the analytic normal CDF and inspect the largest node.

22. Counterexample: high dimension

A 12-factor Gaussian credit portfolio with 15 nodes per factor would require 1512 tensor evaluations—impossible.

Falsifier: compute node count before writing the pricer. If it is already prohibitive, use factor reduction, sparse grids, quasi-Monte Carlo or another high-dimensional method.

23. Counterexample: heavy-tailed factor

If the true integration weight is Student-t or strongly skewed, forcing it into Gauss–Hermite may put nodes in the wrong places.

One can sometimes transform the variable through its CDF, but the resulting integrand may become less smooth.

Falsifier: compare against adaptive quadrature or direct Monte Carlo under the actual distribution.

24. Counterexample: a narrow payoff feature

A payoff can contain a sharp narrow bump between standard Gauss nodes.

Polynomial exactness does not guarantee the feature is sampled.

Falsifier: shift/adapt the integration design or split the domain around known discontinuities/features.

25. Greeks

If the integrand is smooth in a model parameter θ, differentiation can sometimes be moved inside the quadrature:

∂E[g(Z;θ)]/∂θ ≈ Σ weighted ∂g/∂θ.

This can provide deterministic Greeks.

But non-smooth payoffs and parameter-dependent transformations can create the same derivative difficulties seen in other pricing methods.

26. Relation to Monte Carlo

Monte Carlo pricing algorithms scale much better with dimension and path dependence but converge statistically at roughly N−1/2 without extra structure.

Gauss–Hermite can converge vastly faster for one- or two-dimensional smooth Gaussian integrals, but tensor cost grows exponentially with dimension.

27. Relation to Sobol quasi-Monte Carlo

Sobol QMC targets moderate/high-dimensional integration by replacing random points with low-discrepancy sequences.

Gauss–Hermite instead exploits a known Gaussian weight and polynomial exactness in low dimension.

28. Relation to covariance conditioning

Multivariate quadrature often begins from a covariance factorisation.

If Σ is not positive semidefinite because of estimation noise, Cholesky factorisation fails before quadrature begins.

Correlation-matrix repair algorithms own that upstream validity problem.

29. Alternatives

Gauss–Legendre: bounded-domain plain-weight integrals.

Adaptive quadrature: useful when local features/discontinuities dominate.

Clenshaw–Curtis: nested Chebyshev nodes and flexible adaptive constructions.

Smolyak sparse quadrature: moderate-dimensional smooth problems.

Monte Carlo/QMC: higher dimension and path dependence.

30. Weak links

  • wrong Hermite convention/scaling;
  • insufficient order for tail payoffs;
  • non-smooth integrand;
  • tensor explosion;
  • bad covariance factorisation;
  • unverified factor reduction;
  • using polynomial exactness as proof for non-polynomial payoffs;
  • reporting one quadrature order without convergence tests.

31. What would falsify confidence?

Confidence should be withdrawn if standard-normal moment tests fail; if analytic benchmarks do not converge with order; if tail-sensitive prices oscillate materially; if factor reduction changes results; if dimension makes tensor evaluation impractical; or if Monte Carlo/adaptive methods consistently deliver more reliable error control for the same problem.

32. Verification and update triggers

Preserve quadrature convention, node-generation library/version, order n, Gaussian transformation, covariance factorisation, factor-reduction rule, model function and complete order-convergence table.

Revalidate when:

  • dimension changes;
  • distribution ceases to be Gaussian/conditionally Gaussian;
  • payoff becomes discontinuous or tail dominated;
  • covariance structure changes;
  • factor reduction changes;
  • quadrature library changes;
  • Greek accuracy becomes material.

33. Primary and high-quality references

  • Golub, G. H. and Welsch, J. H. (1969), Calculation of Gauss Quadrature Rules, Mathematics of Computation.
  • SciPy, roots_hermitenorm documentation, including exactness and stable node/weight algorithms.
  • Abramowitz and Stegun, Handbook of Mathematical Functions, Hermite-polynomial and Gaussian-quadrature references.
  • Bungartz and Griebel’s sparse-grid literature for extending tensor quadrature ideas to higher dimensions.

Educational boundary: Gauss–Hermite quadrature is powerful because it matches Gaussian structure. Its accuracy must still be demonstrated by scaling tests, order convergence, tail diagnostics and dimensional-cost checks.