Hawkes Processes. Self-Exciting Point Processes for Finance

Randomness in finance is usually imported. Brownian motion comes from outside, and even in a Lévy process the jumps arrive at exogenous times. The Hawkes process is different: it is self-exciting, and past events raise the probability of future ones. Trading begets trading, defaults come in strings, news cascades. Those are not add-ons to the model. They are its definition.

Nearly all the technical content here orbits one number: the branching ratio $n$. It is the stationarity criterion, the fraction of events that are endogenous, the factor by which variance exceeds Poisson, the amount by which the power spectrum lifts at low frequency, and the quantity calibration most reliably underestimates. Every section below computes the same $n$ from a different angle.

From Point Processes to the Hawkes Intensity

A point process on the real line is a random countable set of event times $\{T_1, T_2, \ldots\}$: trade times of a stock, default times in a credit portfolio, earthquake occurrences, order arrivals in a limit order book.

The simplest is the Poisson process, where events arrive at constant rate $\lambda$, the count in $[0, t]$ is Poisson with mean $\lambda t$, and inter-arrival times are i.i.d. exponential with mean $1/\lambda$. One step looser is the non-homogeneous Poisson process, whose rate $\lambda(t)$ varies over time while events remain conditionally independent given the rate.

A Hawkes process makes that rate depend on the events that have already happened. The intensity at time $t$ is

where $\mu > 0$ is the background rate and $\phi: [0, \infty) \to [0, \infty)$ is the kernel function, describing how one past event lifts the intensity afterward. The $\mu$ term ensures positive intensity even when nothing has happened yet, and $\phi$ is typically decreasing, so distant events matter less than recent ones.

Note the essential difference. A non-homogeneous Poisson process has an $\lambda(t)$ handed to it from outside. A Hawkes process writes its own.

The Kernel and the Branching Ratio

$\phi$ decides how excitation decays. The exponential kernel $\phi(s) = \alpha e^{-\beta s}$ gives AR(1)-like decay at rate $\beta$ and is the workhorse, because under it the intensity $\lambda_t$ is itself Markov, which is what makes the model analytically tractable. The power-law kernel $\phi(s) = \alpha (1 + s)^{-(\beta+1)}$ decays more slowly and captures long memory. A sum of exponentials, $\phi(s) = \sum_i \alpha_i e^{-\beta_i s}$, is a flexible parameterization that can approximate any kernel.

Whichever kernel you pick, one functional collapses it to a single number:

which for the exponential kernel is $n = \alpha / \beta$. This is the branching ratio, and the rest of this article is largely an explanation of it.

First Identity: Stationarity

The process is stationary if and only if $n < 1$. For $n \geq 1$ the intensity grows without bound and the process explodes.

The intuition comes from the branching structure. Treat each event as a “parent” that generates “offspring” according to a Poisson process with intensity $\phi(t - T_i)$; the offspring become parents of their own offspring, recursively. Each parent produces $n$ direct offspring on average, so the whole family is a branching process. For $n < 1$ the cascade dies out and any single ancestor has almost surely finitely many descendants. For $n \geq 1$ it grows forever.

This structure is what makes the Hawkes process special. It is not merely an intensity formula but a generative model with a clean probabilistic reading: every event is either an “immigrant” arriving from outside at rate $\mu$ or a descendant of an existing event. The shape of the cascade can be analyzed through generating functions.

That also hands you a second reading of $n$: in the stationary state, the fraction of events that are descendants is exactly $n$. At $n = 0.5$, half of everything you observe was triggered by something else you observed.

Second Identity: How Much the Variance Inflates

The mean intensity of a stationary Hawkes process is

so each immigrant brings on average $1/(1-n)$ events, itself plus its whole line of descendants. It diverges as $n \to 1$, which is the stationarity condition restated.

The variance of the count is more interesting. It grows linearly in $t$, but with a bigger coefficient than Poisson:

so the Fano factor, variance over mean, is

A Poisson process has a Fano factor of exactly 1. At $n = 0.5$ Hawkes gives 4, and at $n = 0.7$ roughly 11. Same average number of events, variance an order of magnitude larger, and the multiplier is set entirely by $n$.

This is precisely the empirical regularity in trade data. Trades cluster in time, and a large trade is followed by a string of others. Describe that with a Poisson process and you will systematically understate the variability, not by a little but by a factor of $(1-n)^{-2}$. Hawkes puts the cluster back in.

Third Identity: The Power Spectrum

The same fact reads more cleanly in the frequency domain. The power spectral density of a stationary Hawkes process with exponential kernel is

Substituting the exponential kernel and simplifying:

Read both ends. As $\omega \to \infty$, meaning very short timescales, $S \to \Lambda / 2\pi$, the Poisson baseline. At fine enough resolution you cannot see self-excitation at all, because clustering is the slow variable. As $\omega \to 0$, meaning long windows,

The low-frequency end is lifted above Poisson by a factor of $1/(1-n)^2$, the same number as the Fano factor. That is not a coincidence: the variance of long-window counts is what the spectrum near zero frequency measures.

The corner sits at $\omega \approx \beta - \alpha = \beta(1 - n)$, which is a timescale of $1/[\beta(1-n)]$. Note it is longer than the single-kernel decay time $1/\beta$, longer by a factor of $1/(1-n)$: one excitation fades on the scale of $1/\beta$, but an entire cascade takes longer to settle, and the closer $n$ is to 1 the longer it drags.

Empirically, trade-time data does show this shape. Fitting it recovers $\mu$, $\beta$, and $n$, giving an independent check against maximum likelihood.

The Intensity SDE and Simulation

The exponential kernel buys one more thing: an SDE you can integrate directly.

with $N_t$ the counting process. Between events $\lambda_t$ mean-reverts toward $\mu$ at rate $\beta$; at each event it jumps by $\alpha$. Continuous mean reversion plus discrete jumps, with a long-run average level that is exactly the $\mu/(1-n)$ from before.

Simulation follows that structure. Between events the intensity decays as $\lambda_t = \mu + (\lambda_{T_i} - \mu) e^{-\beta(t - T_i)}$, and at each event $\lambda_{T_i^+} = \lambda_{T_i^-} + \alpha$. Since the intensity only falls between events, the current value is an upper bound for the entire interval ahead, which is what makes Ogata’s thinning algorithm efficient: draw a candidate time from a Poisson process at rate $\bar\lambda$, then accept or reject it by the ratio of the true intensity to that bound.

import numpy as np

def simulate_hawkes(mu, alpha, beta, T, seed=42):
    """Simulate a Hawkes process with exponential kernel via Ogata's thinning."""
    rng = np.random.default_rng(seed)
    if alpha / beta >= 1:
        raise ValueError("Process is explosive (branching ratio >= 1).")

    t = 0.0
    lam = mu            # intensity at t = 0, with an empty history
    events = []

    while True:
        # The intensity only decays between events, so its current value is a
        # valid upper bound for the whole interval ahead. Refreshing the bound
        # at every step is what keeps the acceptance rate high.
        lam_bar = lam
        dt = rng.exponential(1.0 / lam_bar)
        t += dt
        if t >= T:
            break
        lam = mu + (lam_bar - mu) * np.exp(-beta * dt)   # decayed intensity
        if rng.uniform() < lam / lam_bar:                # accept the candidate
            events.append(t)
            lam += alpha                                 # the jump
    return np.array(events)

Two details are worth flagging. The bound must be refreshed at every step: taking it once at the start and only ever raising it stays correct but drives the rejection rate up over time, and the simulation crawls. And this starts from $\lambda_0 = \mu$, corresponding to no history before $t = 0$; for stationary samples, discard a burn-in stretch. The algorithm has no time-discretization error, and $N$ events cost $\mathcal{O}(N)$ with a small constant.

Calibration: Getting $n$ Out

Given observed event times $\{T_1, \ldots, T_N\}$, the log-likelihood is

The first term is the compensator, available analytically for the exponential kernel: $\int_0^T \lambda(t)dt = T\mu + \sum_i \frac{\alpha}{\beta}\left(1 - e^{-\beta(T - T_i)}\right)$. The second, with the recursion the exponential kernel permits, is also $\mathcal{O}(N)$. Each evaluation is therefore cheap and gradient ascent converges in a few iterations. More complex kernels fall back on numerical gradients; EM is also available for the exponential kernel, with a closed-form M-step at fixed $\beta$, though $\beta$ itself still needs a numerical search. Under standard regularity conditions the MLE is consistent and asymptotically normal, with standard errors from the Fisher information.

On trade data the workflow runs roughly like this: take timestamps of every trade in the asset over a sample period; keep only regular trading hours; assemble the log-likelihood from the two terms above; optimize with scipy.optimize.minimize from several starting points to dodge local optima; then sanity-check, since the branching ratio must land between 0 and 1 and the decay rate should match the asset’s trading frequency, fast for high-frequency names and slow for illiquid ones.

Each parameter reads plainly. $\mu$ is the exogenous rate of orders, the ones not caused by previous orders. $\alpha$ is the excitation per event. $\beta$ is the decay rate, so $1/\beta$ is the timescale over which influence fades. And $n = \alpha/\beta$ is the fraction of orders that are descendants.

Fourth Identity: The Number You Will Underestimate

The MLE is consistent and asymptotically normal, but finite-sample bias can be substantial and its direction is systematic: the branching ratio comes out low.

The reason is that you see one realization of the cascade. If this particular sample’s cascades happen to run shorter than average, your $\alpha$ comes out small. The closer $n$ is to 1 and the shorter the observation window, the worse the bias, which is exactly the regime where you most want $n$ to be right. The remedies are the usual ones: long observation windows starting at a full trading day, pooling across assets where that is defensible, and bias correction via bootstrap or jackknife.

There is a larger trap. The estimate of $n$ depends heavily on the kernel family and the timescale you chose. On the same data, an exponential kernel fitted at second-level timescales typically puts liquid equities at 0.3-0.7, while a power-law kernel with longer memory pushes the estimate considerably higher. Hardiman, Bercot and Bouchaud (2013) obtain branching ratios close to 1 with power-law kernels and read them as evidence of critical reflexivity in markets. That disagreement is unresolved, and the practical stance is that the branching ratio is not an intrinsic property of an asset; it is a function of the kernel family and the timescale. Report those two alongside any $n$ you quote.

Application One: Order Arrivals in High-Frequency Trading

Order arrivals in a limit order book are the most successful application. The self-excitation captures something direct: large orders trigger follow-on orders because participants react to the information embedded in trade flow. Empirically the decay rate $\beta$ runs on scales of seconds to minutes, varying by asset.

Practitioners use the model in three places. Market impact modeling: predict how far a large order moves the price by simulating the cascade of follow-on orders. Optimal execution: decide how to slice a large order to minimize that impact. Liquidity provision: set bid-ask spreads that price in the probability of being picked off by informed flow. The model is now standard in academic market microstructure and is used at several trading firms.

In all three, the branching ratio is the parameter that matters most, because it measures how fragile the order flow is to intervention. High $n$ means a small intervention gets amplified by the cascade, which cuts both ways since your own orders get amplified too. Low $n$ means the flow is robust and pushing on it mostly bounces back. That is the trading-desk reading of $n$, and it is the same fact as the variance reading and the spectrum reading.

Application Two: Default Cascades in Credit

Defaults cluster: when one company defaults, its counterparties and competitors become more likely to follow. This is the default cascade.

A Hawkes process models the arrival of defaults in a portfolio, with the intensity of new defaults depending on past defaults and the kernel representing the propagation of distress. For a portfolio of $n$ credits,

where $\phi_{ij}$ is the impact of credit $j$‘s default on credit $i$‘s default intensity. The cross-kernels $\phi_{ij}$ for $i \neq j$ capture contagion, and the diagonal kernels $\phi_{ii}$ capture autocorrelation in a single credit’s defaults, rare individually but relevant at portfolio level.

The difficulty is data. Defaults are scarce, $\phi_{ij}$ has $n^2$ degrees of freedom, and the observations number in the dozens. The 2008 financial crisis provided a natural experiment for estimating contagion, and most calibrations find moderate but non-trivial cross-kernel effects. Be especially careful quoting branching ratios here, since small samples make the downward bias from the previous section severe.

Application Three: Operational Risk and Insurance

Operational loss events (fraud, system failures, errors) cluster the same way: after a major event more follow, because root-cause analysis surfaces related problems and regulatory attention swings around. Insurance claims have the same shape, with claims bunching after a hurricane or an earthquake, and modeling that clustering with a Hawkes process improves reserving.

Branching ratios in operational risk are often estimated at 0.1-0.5 depending on event type. Fraud runs higher, since one fraud tends to uncover related ones, while system failures run lower because infrastructure is more independent. These figures carry the same kernel-and-window dependence, so treat them as orders of magnitude.

Multivariate and Marked: Two Necessary Extensions

Every application above has already outgrown the one-dimensional model. Multiple interacting point processes need the multivariate Hawkes, whose intensity is a vector:

where $T_j^k$ is the $k$-th event of process $j$ and $\phi_{ij}$ is the kernel from $j$ to $i$. The branching ratio becomes a matrix $N_{ij} = \int \phi_{ij}(s) \, ds$, and stationarity becomes the requirement that the spectral radius of $N$ be less than 1. Same criterion, promoted from a scalar to a spectrum. This is the basis for modeling correlated trade flows across assets, default cascades across credits, and operational risk across business lines. High-dimensional systems (100+ credits, say) are hard to calibrate, and practice relies on moment closures or low-rank structure.

The other direction is marks: each event carries information beyond its time. For trades the mark is size, direction, and price; for defaults it is loss-given-default; for operational events it is severity. Marked Hawkes lets the intensity depend on the marks of past events,

with $M_i$ the mark of event $i$. The common form in microstructure lets the amplitude scale with trade size, written as $\phi(s, m) = \alpha(m) e^{-\beta s}$. Large trades excite more than small ones, which is one of the more stable facts in the data.

It Is Not a Cox Process

One claim circulates widely in the credit-risk literature and needs correcting: the Hawkes process is not a special case of a doubly-stochastic (Cox) process.

Both are written as “random intensity plus conditionally Poisson events,” but a Cox process requires the intensity to be driven by an exogenous random source, such that conditional on the intensity path the events really are Poisson. A Hawkes intensity is endogenous, determined by its own event history, so conditioning on the intensity is conditioning on the events themselves and that conditional Poisson structure does not hold. What they share is the conditional-intensity (compensator) framework, not double stochasticity.

This distinction is not pedantry. It is why $n$ means anything. In a Cox model all clustering comes from an external driving factor; in a Hawkes model it comes from the process itself, and $n$ measures how much of the clustering is endogenous. Fit the same event data with both and the risk implications diverge completely, because exogenous clustering can be forecast by observing the driver while endogenous clustering can only be tracked through the events.

More general models take both. Make the background rate $\mu$ itself stochastic, a CIR process for instance, and you get exogenous shocks and endogenous cascades in one object. $n$ still answers the same question there, with an extra block of exogenous variance in the denominator.

The Boundaries of Linear Hawkes

Everything above is the “linear” Hawkes process, whose intensity depends linearly on past events through that sum in the definition. It is the most common form and it has three clear limits. Excitation only: past events can only raise future intensity, with no way to express “it just happened, so it is less likely again soon.” Monotone decay: the kernel is typically monotone-decreasing in time since the event. Stationary exogenous rate: the background rate $\mu$ is constant.

Breaking any of them requires a different model. Nonlinear Hawkes lets intensity depend on past events through a nonlinear function, capturing inhibition and saturation, such as the “the queue is already long so no new orders arrive” effect in cancellation patterns. Marked Hawkes was covered above. Hawkes with exogenous drivers makes $\mu$ a stochastic process. For most finance applications the linear version suffices, and the extensions are for specific phenomena.

Lined Up Against Other Point Process Models

The Poisson process has no clustering and no excitation and serves as the baseline. A renewal process has i.i.d. but non-exponential inter-arrival times, which produces some clustering, but that clustering comes from the shape of the interval distribution rather than from self-excitation; it has no memory, so ten dense events in a row do nothing to bring the eleventh forward. State-space models let intensity depend on an unobserved Markov state, more general but harder to calibrate, and they attribute clustering to an exogenous state, which puts them on the Cox side of the line.

The discrete-time counterpart is the family of integer-valued autoregressive count models (INAR and relatives), where the current count depends on past counts, a mechanism that corresponds to Hawkes self-excitation with time chopped into bins. When data is naturally aggregated (daily counts, say) those are the natural tool; when you have continuous timestamps, Hawkes is. As an aside, the branching structure of Hawkes shares its mathematics with Yule and preferential-attachment models, since all are branching processes, but they are not continuous and discrete versions of the same model, so do not push that analogy far.

Among all of these, Hawkes is the simplest model that captures self-excitation. The branching interpretation makes it interpretable, the exponential-kernel version is analytically tractable, and the multivariate and marked extensions cover most applications.

Economic Reading and Microstructure

Bowsher (2007) brought multivariate point-process methods systematically into the econometric analysis of market events, letting trades, quote revisions, and the rest sit inside one coupled intensity system for estimation. Work in this line connects the empirical regularity (trade clustering) to economic primitives (information arrival, trader heterogeneity, strategic timing), so fitted parameters mean more than curve fits.

To be clear about what it delivers: an econometric framework and interpretability, not a theorem deriving the Hawkes form from an equilibrium. In practical work you do not need a microfoundation, you just fit the process to the data. But knowing the economic reading helps you tell when a calibration is nonsense.

The modern form of this line is the limit order book model. The book is modeled as a queueing system, with Hawkes processes supplying order arrivals at each price level. A full LOB model has several coupled Hawkes processes, one or more each for market buys, market sells, limit buys, limit sells, and cancellations, with cross-excitation capturing the dependencies (a market buy can trigger limit buys at lower prices, and so on). It is computationally heavy but produces realistic order flow, and calibration is hard but tractable for liquid assets.

Closing

If you have event data that clusters in time, fit a Hawkes process and read two numbers. $1/\beta$ gives you the timescale of the excitation. $n$ gives you how much of the clustering is endogenous, and with it how much larger than Poisson the variance runs (by $(1-n)^{-2}$), how much the long-window spectrum lifts (the same factor), how long a cascade takes to settle ($1/[\beta(1-n)]$), and how sensitive the system is to intervention. When you report that number, report the kernel family and the timescale with it, and remember that finite samples push it low.

References: Hawkes (1971), “Spectra of Some Self-Exciting and Mutually Exciting Point Processes”, Biometrika 58(1): 83-90, the original paper and the source of the spectrum above; Bacry, Mastromatteo & Muzy (2015), “Hawkes Processes in Finance”, Market Microstructure and Liquidity 1(1), the standard review for finance applications and the one to read if you are serious about this; Hardiman, Bercot & Bouchaud (2013), “Critical reflexivity in financial markets: a Hawkes process analysis”, European Physical Journal B, on how branching-ratio estimates depend on the kernel family; Bowsher (2007), “Modelling security market events in continuous time: Intensity based, multivariate point process models”, Journal of Econometrics, for the multivariate point-process econometrics.