Extracted main text — title through conclusion, appendix excluded. This is what our citation measures are computed over, published so the extraction can be checked by eye.
88,650 characters · 23 sections · 52 citation commands
Sluggish news reactions: A combinatorial approach for synchronizing stock jumps
{\it Keywords:} Asynchronicity; Cojumps; High-frequency data; Microstructure noise; Realized Covariance; Rearrangement
Major economic news, such as pre-scheduled announcements, natural disasters or geopolitical conflicts, trigger common jumps in related stock prices li2017mixed. Statistical tests for these common jumps, or so-called “cojump tests", implicitly assume that jumps occur simultaneously in relevant assets but, in fact, jumps occur asynchronously in transaction prices. Stock prices can move sluggishly bandi2017excess, jumps can be gradual barndorff2009realized and jumps of less-liquid individual assets typically lag those of the more-liquid market index li2017mixed. Most researchers have dealt with this problem by settling for a coarse sampling grid barndorff2009realized,bollerslev2008risk,lahaye2011jumps,li2019rank. Such a coarse grid guards against microstructure effects, the frictions with which actual trades take place, but it is restrictive in that it oversmooths actual changes ait2004disentangling.
Frictions in financial markets may cause observed prices to deviate from the underlying underlying equilibrium (often called “efficient") price. Features such as tick size, discrete observations, bid-ask spreads, adverse selection, liquidity and inventory control produce market microstructure noise christensen2014fact, leemykland2012jumps. Prices may also be sluggish because market participants must trade to reveal private information and reach a consensus about the impact of some piece of news. \fi
We offer an alternative strategy which changes the time labels of some financial time series observations on a fine sampling grid to approximately recover the efficient common jump in a basket of stocks. Asynchronous impoundment of news causes the value of a synthetic stock index to deviate from the price of an exchange-traded fund (ETF), even though they consist of the same stocks. Assuming that an ETF price tracks the latent, equilibrium (often called “efficient") value of a stock index, the spread between the value of a synthetic index and the ETF price measures the sluggishness in news reactions. Combinatoric methods rearrange jumps to minimize the spread and approximately recover the latent efficient price.
To rearrange stock jumps, we extend the pioneering work of puccetti2012computation and embrechts2013model on rearrangements. Their rearrangement algorithm is best known as an actuarial tool to bound portfolio risk, but it can also be applied to other disciplines, such as operations research boudt2018block. Rearrangements can also synchronize stock jumps and recover the common jump on a fine sampling grid, provided we penalize economically implausible rearrangements. For example, we only allow for a rearrangement of jumps backward in time because we assume that stock prices are sluggish and lag the highly liquid and carefully watched ETF, they do not lead it.
We apply our methods to investigate the reactions of Dow 30 stock prices in event windows around DIA ETF jumps. For example, the Federal Reserve announced rate cuts on September 18, 2007, at 14:15 US Eastern Time, after which markets took up to five minutes to incorporate the Fed’s news into the Dow 30 stock’s prices. Rearrangements synchronize 19 (out of 23) scattered stock jumps with the ETF jump, approximately recovering the common jump in the stocks. This is not a stand-alone event: the rearrangement linear program rearranges stock jumps in 180 cases.
\if10 {\textcolor{darkblue}{And we find what earth-shaking result? Add summary statistics and a convincing application.}} \fi Synchronizing mistimed stock returns improves estimates of the daily realized covariance matrix. Other estimators, like the multivariate realized kernel in barndorff2011multivariate or a Cholesky factorization in boudt2017positive, protect against mild market microstructure noise and the epps1979comovements effect, that is, the downward bias in covariance estimates due to asynchronous trading. But rearranging returns protects against the underestimation of jump dependence due to asynchronous jumps and improves the out-of-sample financial performance compared to using raw returns.
We proceed as follows. Section (ref) details the synchronization method using a toy example. Section (ref) illustrates an empirical example of a rearranged sluggish cojump in the Dow 30 and includes a portfolio allocation exercise. Section (ref) concludes.
A salient feature of multivariate high-frequency financial data is the occurence of non-synchronous trading; it is rare for any two assets to trade simulataneously. This leads to prices at irregularly spaced times, differing across assets. Addressing asynchronicity through the coordinated collection of multivariate data has been an active area of research in financial econometrics in recent years, see e.g., barndorff2011multivariate or boudt2017positive and the references therein, and the concept of so-called “stale" prices has been integral to covariance estimations since epps1979comovements. Nonetheless, the state-of-the-art sampling schemes like refresh-time sampling barndorff2011multivariate, are not tailored to price jumps, with asynchronous jumps not necessarily resulting from non-synchronous trading. At times, prices may be “sluggish"; the asset might be trading, but due to various factors, the news might not yet be impounded in the price. To address this problem, we synchronize the timing of multivariate jumps using what we call “Jump Sampling". This technique refines the detection of high-frequency cojumps and, in turn, the realized covariance matrix.
Figure (ref) compares refresh-time sampling to jump sampling in the presence of asynchronous observations and jumps. It draws inspiration from the well-known Figure 1 in barndorff2011multivariate, illustrating refresh-time in a situation with three assets (without the occurence of jumps). We expand upon this concept to include scenarios with asynchronous price jumps, focusing on three specific assets: a basket instrument and its two underlying stocks. In each asset's case, the filled dots indicate the updates in posted prices, and an open dot pinpoints the time at which the price jumps. Vertical dashed lines represent the sampling times generated from the three assets, using the refresh-time sampling approach. For example, the first black dot represents the time it has taken for all three assets to trade. But because asynchronous jumps are not due to (il)liquidity issues, refresh-time sampling does not resolve the asynchronicity inherent in the jumps. As a solution, we introduce a new jump sampling scheme, which rearranges mistimed jumps to occur simultaneously with the ETF jump.
In what follows, we detail how we synchronize stock jumps using combinatorics. We optimally rearrange jumps, penalizing economically implausible rearrangements. A simulated example clarifies the mechanics of the rearrangements.
We assume a data generating process for the sluggish prices of the stocks in the index, which features gradual jumps and jump delays.\footnote{Gradual jumps are when the prices exhibit strong linear trends for periods of a few minutes barndorff2009realized. Jump delays are when jumps of individual assets follow those of the highly liquid market index during market-wide events li2017mixed.} A jump in the underlying equilibrium price may not be immediately reflected in the observed price due to various trading frictions. Such complications are not captured in the standard martingale-plus-noise price model, but they are important in the empirical analysis of multivariate jump processes.
Let ${X}_t = (X_{1,t}, ..., X_{p,t})^\top$ denote the logarithmic $p$-variate, equilibrium (or so-called “efficient") price of the $p$ stocks in the market index. The price process is defined on a filtered probability space $(\Omega, \mathcal{F}, (\mathcal{F})_{t \geq 0}, \mathbb{P})$ and is adapted to the filtration $\mathcal{F}_t$ that represents information available to market participants at time $t$, with $t \geq 0$. We assume that ${X}$ operates in an arbitrage-free, frictionless market, which implies that ${X}$ is a semimartingale. Econometricians ait2014high model stock prices ${X}$ as a jump-diffusion process, which includes a continuous Brownian component and a discontinuous jump component:
in which $t \geq 0$, ${b}$ is the drift process, ${\sigma}$ is the stochastic (co)volatility process, ${W}$ is a multivariate Brownian motion and $\Delta {X}_t \equiv {X}_t - {X}_{t-}$, with ${X}_{t-}$ the left limit at time $t$, denotes the jumps of ${X}$ at time $t$. A stock's growth prospects generates a jump in single stock price. Major economic news, such as pre-scheduled announcements, natural disasters or geopolitical conflicts, trigger common (i.e. synchronous) jumps in related stock prices li2017mixed.
In practice we do not observe the price process in (ref). Instead we observe discretely sampled, noisy transaction prices. Frictions such as tick size, discrete observations, bid-ask spreads, adverse selection, liquidity and inventory control produce market microstructure noise christensen2014fact, leemykland2012jumps,li2022remedi. Prices may also be sluggish because market participants must trade to reveal private information and reach a consensus about the impact of some piece of news. If trades do not occur at the time a jump in the underlying efficient price occurs, then observed news reactions can be sluggish because trading is not continuous even if market participants are constantly aware of fundamentals.
We model the observed log price process ${Y}_t = (Y_{1,t}, ..., Y_{p,t})^\top$ of the $p$ stocks as contaminated version of (ref) observed at discrete intervals:
There are two kinds of noise: microstructure noise and mistimed jumps. Microstructure noise ${u}$ contaminates the efficient price process ${X}$, but is typically too small to substantially contaminate the discontinuous part ${X}^d$. It can neither generate gradual jumps barndorff2009realized nor jump delays li2017mixed. We capture the mistimed or mismeasured jumps in a separate noisy jump component ${Y}^d$, which allows a sluggish news reaction, spreading the stock jump across several time intervals.
Figure (ref) shows a simulated sample path of this new DGP for 1 stock. The top panel of Figure (ref) illustrates that the efficient stock price jumps at 12:45 in reaction to news. In the following 112 seconds, the observed price (in black) catches up with the new equilibrium level (in gray) by gradually matching the jump. The middle and bottom panels respectively decompose the price process into its continuous Brownian component and its jump component. The middle panel compares the efficient, continuous price with the one contaminated by mild market microstructure noise. The bottom panel compares the efficient, sudden jump with the contaminated, gradual jump. Our assumed DGP uses a step function to model how observed prices incorporate news. Appendix (ref) shows how to spread the jump across several time intervals.
The observed price process (ref) combines the frictions and the sampling frequency. We sample discretely at time points $i\Delta_n$, with $i = 0, ..., \lfloor T / \Delta_n \rfloor$, across a time span $T$, in which $\lfloor \cdot \rfloor$ denotes the floor function. There is less noise on a coarse sampling grid, i.e. at a lower sampling frequency $\Delta_n$, but data at such lower frequencies tend to oversmooth actual changes bollerslev2008risk, lahaye2011jumps, li2019rank. The finer the sampling grid, the higher the probability that a jump can be recognized as such ait2004disentangling.
When multiple stocks react sluggishly to new information, their jumps are asynchronous on a fine sampling grid, and these jumps will generally not coincide with the jump in the price of an index tracker. Empirical evidence corroborates this prediction: jumps of less-liquid individual assets typically lag those of the more-liquid market index li2017mixed and the ETF jumps more often than a synthetically constructed index of stocks bollerslev2008risk.
Let $w_{k,t}$, with $k = 1, ..., p$, be the weights allocated to each stock in the market index at each moment in time. The price of the synthetically constructed index portfolio, $S_{i\Delta_n}$, is a linear combination of the observed stock prices in ((ref)), sluggishly incorporating its jump component:
An ETF log price process, $Z_t$, tracks an index of the $p$ stocks. We assume that the observed log price $Z$ replicates a portfolio of efficiently priced stocks (ref), efficiently incorporating its jump component \footnote{To simplify our notation, we rely on a weighted average of individual log returns as opposed to simple returns. This difference is considered as minor in empirical applications \citep*[][pp. 9]{jondeau2007financial}.}:
The deviation or spread in prices is the difference between the observed prices on a synthetic index of stocks (ref) and the prices of an observable ETF trading the index (ref):
Similarly, we can also define the spread in returns as the difference between the observed returns on a synthetic index of stocks $\Delta^n_i S := \sum_{k = 1}^p {w}_{k,i\Delta_n} \Delta^n_i {Y}_k$ and the returns of an observable ETF trading the index $\Delta^n_i Z := {Z}_{i \Delta_n} - {Z}_{(i-1)\Delta_n}$ or, equivalently, the percentage change of the price spread in ((ref)):
We expect the ETF log price $Z$ to nearly equal the synthetic log price $S$ in the absence of sluggish prices. Only microstructure noise would separate the two prices. However, asynchronous jumps cause the price of the synthetic index portfolio to deviate from the presumably efficient price of an ETF tracking the index.\footnote{Within our theoretical model descriptions, the difference between the price of the synthetic index and the ETF price (ref) equals microstructure noise component minus the discontinuous component that has not yet been impounded into the observed prices:
This sharp theoretical decomposition is unobservable to the econometrician in empirical data. } The sluggish components of jumps are much larger than microstructure noise, so asynchronous impoundment of news drives the spread in prices. Hence, the spread (ref) between the ETF price and a synthetically constructed index measures the collective misalignment of noisy stock prices with their efficient levels. The goal is to rearrange jumps in empirical data to minimise the spread and recover the latent efficient price.
To illustrate the workings of our procedures, we consider a stylistic 3-stock universe $(p = 3)$ and a corresponding ETF, in which stock prices vary in how quickly they impound news. The stock names A, B and C correspond to the indices $k = 1, 2$ and $3$. The ABC ETF price is an equally weighted average of the underlying stocks' efficient prices (ref) and the synthetic ABC portfolio is an equally weighted average of the stocks' observed prices (ref). The sampling frequency is one minute ($\Delta_n = 1/391$).
Consider the following time series of return vectors of the three stocks and the ABC ETF:
in which the returns are reported in percentages and the jump returns are underlined. Prices asynchronously incorporate news. The first column shows that Stock A jumps gradually and finishes its jump 2 minutes after the ETF in the last column, while the second column shows that stock B's jump is not gradual but 1 minute late and stock C does not jump (third column).
These delays cause the implied (inefficient) returns of the ABC portfolio to deviate from the efficient ABC ETF returns. The sum of the first three columns of the matrix below, which calculates the return spread $\delta_{i\Delta_n}^r$, is the equally weighted, linear combination of the log returns of stocks A, B, and C (the first three columns in (ref)), that is, the return on the synthetic ABC portfolio. The fourth column on the left side of the equal sign is the log return of the ABC ETF (the last column in (ref)). Their difference, on the right-hand side of equation (ref), is the return spread (ref), in each of the five periods.
In the first two periods, the returns to the synthetic index portfolio are almost the same as the returns to the ETF, producing only a small deviation on the right-hand side. In the third period, the ETF price jumps by $0.807$%, while the prices of the individual stocks do not move much, leading to a large negative spread. In the fourth and fifth periods, the prices of the portfolio of individual stocks catch up to the ETF jump, leading to large positive spreads.
This stylized example captures the central problem in the analysis of common jumps on a fine sampling grid. If news reached the entire market instantly, was interpreted homogeneously, and trading were continuous, jumps in a group of stocks should presumably occur simultaneously with the ETF index jump and the spreads should be small and random. Sluggish price changes lead to asynchronous jumps, however, and the spread temporarily expands and contracts again.
To isolate the effect of asynchronous jumps on the spread, we break up the return of synthetic stock index portfolio $\Delta^n_i S$ into its discontinuous and continuous part:
Jump tests lee2007jumps flag some large observed returns as being jumps. We then classify the observed returns as either discontinuous or continuous:
in which $\Delta^n_i {Y}_k$, for $k = 1, ..., p$, the $i$th return of the one-dimensional observed stock log price process, $Y_k$, is the sum of a discontinuous stock return $\Delta^n_i {J}_k := \Delta^n_i {Y}_k \, \cdot I(\text{Jump}_{i\Delta_n})$ and a continuous stock return $\Delta^n_i {C}_k := \Delta^n_i {Y}_k \, \cdot I(\text{No Jump}_{i\Delta_n})$, in which $I(\cdot)$ is an indicator function. The continuous and sparse jump return vectors are mutually exclusive. A similar classification applies to the ETF return $\Delta^n_i {Z}$.
The return spread (ref) now equals a linear combination of the weighted stock jumps, the weighted continuous stock returns and the ETF returns:
We want to synchronize the individual discontinuous jumps (the first element) with the target (the second element) to minimize the return spreads on the event window. If both the stock jumps and the ETF impound news at the same time -- the stock jumps offset the target -- the spread in returns should be small, containing only microstructure noise.
To synchronize jumps within an event window, we collect the jump vectors of the individual stocks within a window of observations:
in which $\Delta^n_i {J}_{k}$ is the vector of jump returns for stock $k$, with $k = 1, ..., p$, and $\mathcal{W}_n := [{I_1 \Delta_n},{I_2\Delta_n}]$ is an event window of size $h \equiv {I_2\Delta_n} - {I_1 \Delta_n} + 1$. For the empirical application in Section (ref), we use an event window from five minutes before to five minutes after the ETF jump, $I_1 \Delta_n = (i^* - 5)\Delta_n$ and $I_2 \Delta_n = (i^* + 5)\Delta_n$.
To help us rearrange stock jumps, we create an $h \times q$ jump-event matrix $J_n$, that is an easier-to-handle representation of the decomposition in ((ref)), where $h$ is the number of periods in the window around the ETF jump and $q-1$ is the number of jumps in individual stocks, where some stocks might jump more than once or not at all:
in which $i = 1, ..., h$ and $l = 1, ..., q$. The first $q-1$ columns consist of the vectors of weighted stock discontinuous returns ${w}_{i\Delta_n} \Delta^n_i {J} := ({w}_{1,i\Delta_n} \Delta^n_i {J}_1, ..., {w}_{q-1,i\Delta_n} \Delta^n_i {J}_{q-1})$ sampled within a window of $h$ observations around the ETF jump. The weighted jump vectors ${w}_{i\Delta_n} \Delta^n_i {J}$ consist of the $p$ stock jump vectors $\Delta^n_i {J}_k$, for $k = 1, ..., p$ in ((ref)), but we reorganize the stock jump vectors. If a stock jumps multiple times, as does stock A, separate jumps appear in different columns. Each jump vector contains one and only one non-zero element. We exclude the jump vectors for which the stock does not jump, as in the case of stock C. The $q$th column is the target vector, $T_{i\Delta_n} := (\sum_{k = 1}^p {w}_{k,i\Delta_n} \Delta^n_i {C}_k) - \Delta^n_i Z$, which is the difference between the continuous returns of the synthetic stock index portfolio, $\sum_{k = 1}^p {w}_{k,i\Delta_n} \Delta^n_i {C}_k$, and the ETF returns $\Delta^n_i Z$. The elements of the target column cannot be moved, while the stock jumps are the moving parts of the jump-event matrix.
Spreads are linear combinations of the stock jumps, the stock's continuous returns and the ETF returns ((ref)). They are the row-sums of the jump-event matrix:
The jump-event matrix (ref) in our example looks like:
The first three columns of the jump-event matrix correspond to the individual stock jumps across an event window from two minutes before to two minutes after the ETF jump. Note that the number of columns in the first block corresponds to the number of identified jumps in individual stocks, not the number of individual stocks. The first two columns contain the gradual jumps of Stock A and the third column contains the delayed jump of stock B. The stock jump sizes are generally weighted according to their shares of the index, but this example uses an equally weighted index for simplicity. The fourth column of the jump-event matrix is a target vector that contains the difference between the continuous returns of the stocks and the ETF returns. The return spread is the sum of the row-sums of the weighted discontinuous stock returns and the target column, i.e. the row-sums of the jump-event matrix ((ref)). As before (in (ref)), there is a negative and a positive spike in the return spread in a small window around the ETF jump in period $3$, because stocks A and B do not jump until periods $4$ and $5$.
After decomposing the stock returns into jump and non-jump returns, we can rearrange the stock jumps in the jump-event matrix to offset the target column.
There are different choice options for the rearrangements, making it a combinatorial optimization problem. We seek to rearrange the stock jumps in the jump-event matrix (each individual column in the first block of columns in the jump-event matrix) to offset the elements in the target vector (the last column in the jump-event matrix), which minimizes the variability of return spreads (the row-sums of the jump-event matrix).
A rearrangement (of a particular column in the jump-event matrix) is defined by a permutation ${\pi}_l$ of its $h$ elements: $\pi_l: \{1, ..., h\} \rightarrow \{1, ..., h \}$, with $l = 1, ..., q$. The permutation ${\pi}_l$ is represented compactly by a vector mapping the original row order into a new row order:
The vector of $q$ permutations ${\pi} := ({\pi}_1, ..., {\pi}_q)$ collects the rearrangements of all columns. Note that the $q$th column, the target, is fixed. We do not swap any elements in the $q$th column of the jump-event matrix.
Each rearrangement of an observed jump-event matrix ((ref)) yields a new (“rearranged") jump-event matrix:
\sloppy in which $J^\pi_n = (\gamma^\pi_{il})$ is the rearranged jump-event matrix, ${w}_{i\Delta_n} \Delta^n_i {J}^\pi := ({w}_{1,i\Delta_n} \Delta^n_i {J}^{\pi}_1, ..., {w}_{q-1,i\Delta_n} \Delta^n_i {J}^{\pi}_{q-1})$ is the vector of rearranged weighted stock jump returns.
The row-sums of the rearranged jump-event matrix $J_n^\pi$, i.e. the corresponding return spreads, are expressed as a function of the arrangement (and timing) of the stock jumps:
For example, consider the following permutation ${\pi}_1$ (ref) of the first column of the jump-event matrix, swapping the 3rd and the 4th observation:
This swap rearranges the jump-event matrix, switching the 3rd and 4th rows of the first column:
which shifts a weighted stock jump of stock A one period back in time (and a zero forward in time). The permutation $\pi_1$ also changes the third and fourth row-sum of the jump-event matrix. The variability in the row-sums is slightly smaller after this rearrangement, because the ETF jump also occurs in the third observation.
Under the assumption that the latent prices of the price series of the stocks and the ETF move in lockstep, the best rearrangement moves jumps in time to minimize the variability of the return spreads. This reduction in variability is known as “flattening".\footnote{ Flattening the row-sums of the jump-event matrix means that the stochastic variables in the separate columns of the jump-event matrix should be completely mixable. Mathematically, a $q$-dimensional distribution function $F(Q_1, ..., Q_q)$ on $\mathbb{R}$ is {$q$-completely mixable} if there exist $q$ random variables $Q_1, ..., Q_q$ identically distributed as $F$ such that:
That is, the sums of $q$ random variables drawn from a $q$-completely mixable distribution should approximate a constant. A completely mixable dependence structure minimizes the variance of the sum of the random variables with given marginal distributions. In a discrete case, like the jump-event matrix which consists of realizations of random variables, we look for a particular ordering in each of the columns, such that the row-sums approximate a constant.}
The optimization problem that minimizes the variance of the return spreads is a combinatorial problem that can be expressed as follows:
in which the row-sums $J_n^{\pi,+}$ are return spreads expressed as a function of the arrangement of stock jumps, $V(\cdot)$ is a scalar-valued function that measures the variability, e.g., the range, of the vector of row-sums.
The combinatorial optimization problem ((ref)) is rooted in the pioneering work of puccetti2012computation and embrechts2013model on rearrangements and the Rearrangement Algorithm; looping over each column of a matrix to order it oppositely to the sum of the other columns (see Appendix (ref) for an example). This algorithm is best known as an actuarial tool to bound portfolio risk, but it also has applications in other disciplines, such as operations research boudt2018block. The algorithm can propose a best rearrangement of the jump-event matrix (ref) but it does not constrain the type of rearrangements that take place. For example, it can move jumps either forward or backward in time to any point in the window.
To constrain the procedure from economically implausible rearrangements, we introduce the Rearrangement Linear Program (RLP) that is well suited to choose arguments which minimize an objective function ((ref)), subject to linear constraints (ref) and penalties (ref). \if10 {\textcolor{darkblue}{The next parts (Objective function and Constraints) are badly explained and are in desperate need of a rewrite. Let's first find a decent empirical application and then go for an overhaul of the next subsections.}} \fi
There are two types of arguments to the solution function: 1) permutation matrices and 2) an unknown interval within which all the row-sums lie.
To rearrange (i.e., permute) a column of the jump-event matrix, we premultiply a column by a permutation matrix. We rely on the column representation of a permutation matrix. Each permutation matrix permutes one column of the jump event matrix, so a solution will include $q$ permutation matrices -- 4 columns in the jump-event matrix means there are 4 permutation matrices.
An $h \times h$ permutation matrix permutes the columns of the identity matrix $I_{h}$ to express a permutation $\pi_l$ (ref):
For each $i$, $p_{ii'}$ is $1$ if $i' = \pi_l (i)$ and is $0$ otherwise. The entries of the $i$th row are all zero except for a $1$ that appears in column $\pi_l (i)$. A standard basis vector, $\bm{e}_{i'}$, denotes a row-vector of length $h$ with a $1$ on position $i'$ and a $0$ on every other position.
We rely on this representation because a permutation matrix (ref) can track how far the ones deviate from the diagonal, which permits penalties for movement. For example, we can impose a maximum distance from the diagonal to not let the jumps stray too far in the event window (see Section (ref) for further elaboration).
The permutation in the example of Section (ref), $\pi_1 =
$, switches the 3rd and 4th rows of the 1st column of a jump-event matrix, and is equivalent to the following permutation matrix:
in which column $i'$ of the $I_5$ identity matrix now appears as the column $\pi(i')$ of $P_{\pi_1}$. The changes occur in the vertical, $i$, dimension. Upward moves in the permutation matrix are backward moves in time. Downward moves in the permutation matrix are forward moves in time. The fourth element, which is on position $(4,4)$ in $I_5$, shifts one spot backward in time by shifting one step upward in the permutation matrix. The third element, which is on position $(3,3)$ in $I_5$, shifts one step forward in time by shifting one step downward in the permutation matrix.
We have a permutation matrix for each of the $q$ columns in the jump-event matrix. We concatenate the permutation matrices in a co-permutation matrix of dimension $h \times (h q)$:
with $l = 1, ..., q$, $i,i' = 1, ..., h$ and $P_{\pi_{1}}$ short notation for the $h \times h$ permutation matrix for the first column of the jump-event matrix.
Premultipying the (vectorized) jump-event matrix by the co-permutation matrix produces the vector of return spreads:
or, equivalently:
in which $\text{vec}(J_n)$, the vectorized version of the observed jump-event matrix $J_n = (\gamma_{il})$, with $i = 1, ..., h$ and $l = 1, ..., q$, is a stacked column vector of dimension $hq \times 1$. The result of the matrix product in (ref) is a $h \times 1$ column vector, including the row-sums of the rearranged jump-event matrix (the left side of the equal sign).
The RLP chooses a co-permutation matrix that minimizes the range of the row-sum. The range is the difference between the maximum and the minimum order statistic of the row-sums:
in which the subscript $(i)$ enclosed in parentheses indicates the $i$th order statistic of the sample: the smallest and a largest row-sum for a particular arrangement.
The positions of the smallest and largest row-sums are unknown upfront. In order to express this objective function within the RLP we slightly deviate from the standard canonical forms of linear programs -- the objective function within a linear program is typically an affine function of its arguments.\footnote{Linear programs are problems that can be expressed in canonical form as: “Find a vector $\bm{x}$ that minimizes $\bm{c}^\top \bm{x}$, with $\bm{c}$ a given vector, subject to some constraints on $\bm{x}$."} The co-permutation matrix extracts the row-sum in each row in the matrix product (ref), i.e., $J^{\pi,+}_{n,1}, J^{\pi,+}_{n,2}, ..., J^{\pi,+}_{n,h}$ (without brackets), but there is no possible choice of the co-permutation matrix which could ever produce the maximum or minimum of the row-sums in (ref), i.e., $J^{\pi,+}_{n,(1)}$ and $J^{\pi,+}_{n,(h)}$ (with brackets).
We get the appropriate objective function indirectly, by minimizing an unknown interval within which all the row-sums lie:
in which $\Pi$ is the co-permutation matrix, which defines arrangement of the elements in the rearranged jump-event matrix, $U$ is the upper boundary of an unknown interval and $L$ is the lower boundary of an unknown interval.
The program chooses candidates for both types decision variables -- the permutation matrices and the lower and upper boundary of the unknown interval -- to minimize the range of that interval (ref). The MILP chooses the elements (0,1) for the permutation matrices and continuous values for the lower and upper boundary. The optimization problem (ref) is therefore a mixed-integer linear program (MILP).
The optimization in (ref) does not minimize the range of the row-sums yet. We must define a permutation within a linear program and connect the lower and upper boundary, $L$ and $U$ with the co-permutation matrix $\Pi$ by constraining the choices of the decision variables.
We constrain the sensible choices of the decision variables using three types of constraints: the ordering constraint, the permutation constraint and a target constraint. The combination of these minimal conditions does lead to appropriate rearrangements which minimize the range.
The unconstrained MILP, as it is defined in (ref), has a lower and upper boundary of an unknown interval both in the argument and in the objective function. It can choose any continuous value for the lower boundary $L$ (say, a big negative number) and any continuous value for the upper boundary (say, zero) to minimize the difference between these two random numbers. The minimization will push the difference towards a big negative number, because these optimal boundaries are still unconnected to the co-permutation matrix.
We impose inequality constraints on the boundaries:
in which the row-sums in the middle are the result of the matrix product in (ref) for a particular arrangement of jumps. The constraint indirectly defines the smallest possible (the minimum) and largest possible (maximum) row-sum. The left inequality in (ref) defines a lower boundary in a set of row-sums ({by definition} each individual row-sum should greater than or equal to the minimum) and the right inequality defines upper boundary in a set of row-sums (by definition each individual row-sum should be less than or equal to the maximum). The outer boundaries, the lower boundary should be less than or equal to the upper boundary, ensures that the minimum is always smaller than the maximum, as by definition.
Choosing candidate values for the lower and upper boundary (ref) still result in values which are unconnected to the row-sums. A big negative number for the lower boundary $L$ will satisfy the constraint (ref): $L$ will be smaller than any row-sum. (And a big positive number for the upper boundary will also satisfy the constraint: $U$ will still be larger than any row-sum.) But by minimizing the difference of these decision variables, $U - L$, as defined in (ref), the RLP squeezes the outer values in the constraint (ref) together, as close as possible. (Note that if we would maximize the range, $U - L$, the lower and outer boundary $L$ and $U$ would move away from each other and from the row-sums.) The optimal solutions for $L$ and $U$ will then be equal to the smallest and largest row-sum:
A simple proof by contradiction suffices to confirm this statement. Suppose that $L^*$ is not equal to the smallest row-sum $J^{\pi,+}_{n,(1)}$ or $U^*$ is not equal to the largest row-sum $J^{\pi,+}_{n,(h)}$. In any of those cases, the RLP can still further minimize the objective function $U - L$.
To define a proper co-permutation matrix (ref), we impose equality constraints on the linear program:
The first equation (ref) requires that each permutation matrix ((ref)) has $h$ ones to select all (exactly $h$) elements in each column of the jump-event matrix, so the sum over all permutation matrices in the co-permutation matrix should equal $hq$. The second equation (ref) constrains the rows on each permutation matrix to sum to one. Suppose that the rows of each permutation matrix do not sum to one, then we could have either multiple or zero elements in the rearranged matrix on a particular position. The last equation (ref) is a column constraint on the permutation matrix, which guarantees that the same number does not appear twice in a column of the rearranged matrix, even if the rows sum to one.
We also impose an equality constraint on the permutation matrix of the last column, so that the RLP does not rearrange the last column of the jump-event matrix, i.e. the target:
The permutation (ref) matrix corresponding the $q$th column of the jump-event matrix $P_{\pi_{q}}$ should remain an identity matrix $I_n$.
A linear program is flexible. It allows for the introduction of penalties to prohibit economically implausible rearrangements. For example, we could penalize large moves in time with the aid of a distance matrix. The distance matrix $D_n$ tracks the distance from the diagonal in any permutation matrix $P_{\pi_l}$ (ref) of the same size:
Keeping the elements on the diagonal of a permutation matrix $P_{\pi_l}$ (ref), i.e. no moves, results in a zero distance: the diagonal elements in the distance matrix $D_n$ are zero.
The distance matrix also allows us to enforce an economic assumption: the RLP only allows for a rearrangement of jumps backward in time because we assume that stock prices are sluggish and lag the highly liquid and carefully watched ETF, they do not lead it. That is, we only permit stock jumps to be moved to an earlier time (upward moves in the permutation matrix $P_{\pi_l}$), not a later time (downward moves in the permutation matrix $P_{\pi_l}$). By taking the upper triangular portion of the distance matrix $D_n$, we can focus on the backward shifts in a permutation matrix $P_{\pi_l}$. The upper triangular portion of the distance matrix still tracks the backward distance traveled of all elements in a column of the jump-event matrix, because the permutation matrix (ref) also tracks the rearrangements of the zeros. To only track the move of a stock jump, we disable the irrelevant columns of the distance matrix: if the price jumps in period $i = i^*$, we set the columns $i' \neq i^*$ of $D_n$ to zero.
To limit the length of jump moves in our rearrangements, we impose an inequality constraint on a distance metric:
in which $c \geq 0$ is the maximum permitted length of the backward move and $d(P_{\pi_l})$ is the total distance traveled of a jump within the $l$th column of the jump-event matrix. \footnote{The total number of relevant moves for the $l$th column in the jump-event matrix is equal to the following matrix product of a vectorized permutation matrix and a vectorized distance matrix:
The vectorization, $\text{vecr} (\cdot)$ concatenates the rows of a matrix, as opposed to a standard vectorization which stacks the the columns, producing a $1 \times hq$ row-vector. We transpose the second term after vectorization to get a $hq\times 1$ column-vector. The result of this matrix product is a row-wise multiplication of the elements of the two matrices, which equals the total number of relevant shifts.} We do not constrain the $q$th column, because the RLP keeps the target column fixed in constraint (ref). It is possible to constrain each stock differently depending on the liquidity of the stock.
Figure (ref) shows the range of the spreads, i.e., flatness, and the jump arrival times as a function of the permitted maximum length of the move for each jump in the stylistic jump-event matrix. We allow each jump to move backward in time a maximum of zero, one, two, three, four minutes and solve the RLP for each of these five possible jump-length constraints. The starting range is what we observe: the gradual jump of Stock A (Jump 1 in the 4th period and Jump 2 in the 5th period) and the delayed jump of Stock B (Jump 3 in the 4th period) with a relatively high range of $1.421$. The negative slope of the line in the top panel of Figure (ref) shows that allowing more backward shifts flattens the return spreads.
The bottom panel shows the arrival periods for the jumps as a function of the permitted length of backward moves. With no backward moves, jumps 1 and 3 arrive in period 4 and jump 3 arrives in period 5. If we permit one backward move for each jump, the RLP moves jumps 1 and 3 to period 3 while if we permit 2 backward moves, the RLP moves all jumps to period 3. The smallest range ($0.048$) occurs with two backward shifts, aligning all the jumps in the third period in the bottom panel.
Optimally rearranging the jumps, produces the following transformation of the jump-event matrix:
Figure (ref) shows the implied prices after this optimal arrangement of jump returns. Prices asynchronously incorporate news. That is, the observed (black) prices of stock A and stock B deviate from their efficient (gray) values in the first and second panels. (There are also small deviations in Stock C's observed prices due to a (relatively smaller) contamination of the continuous component.) The fourth panel shows that the delays cause the implied (inefficient) price of the basket of stocks (the ABC portfolio) to deviate from the efficient ABC ETF price. The best rearrangement combines two small jumps of stock A and shifts the jumps of stock B one period backward, aligning the jumps in time. The rearranged price paths (green) are now much closer to the efficient price paths (black) in the 1st, 2nd and 4th panel.
We apply our methods to investigate the reactions of stock prices in event windows around ETF jumps. We illustrate that synchronizing mistimed stock returns increases the Sharpe ratio of a portfolio allocation strategy.
The NYSE Trade and Quote (TAQ) database provides equity trade data with millisecond precision timestamps. The basket instrument is the SPDR Dow Jones Industrial Average ETF (DIA). We compare this ETF to the price of a synthetic index of Dow 30 stock prices, as in bollerslev2008risk.\footnote{ The constituency of the Dow 30 index is dynamic. The 43 unique tickers within our sample period are: AA, AAPL, AIG, AXP, BA, BAC, C, CAT, CSCO, CVX, DD, DIS, DOW, DWDP, GE, GM, GS, HD, HON, HPQ, IBM, INTC, JNJ, JPM, KFT, KO, MCD, MMM, MO, MRK, MSFT, NKE, PFE, PG, T, TRV, UNH, UTX, V, VZ, WBA, WMT and XOM. }
The data cover the period January 3rd, 2007 through April 2nd, 2020, which includes several exceptionally turbulent episodes, such as the global housing and credit crisis, the European sovereign debt crisis and the bail-out of Greece, the Russian, Greek, Turkish crisis and the 2020 stock market crash.
We pre-filter the prices as in barndorff2009realized. We also remove banking holidays, half-trading days, any day where there is more than a two-hour gap between consecutive trades and periods of malfunctioning such as the 2010 flash crash.
\if10 {\textcolor{darkblue}{Add a table with the 10 largest standardized spreads? Is it a jump day? Is there news on those days? Unfortunately the diagnostic is a flawed measure.}} \fi
There are many jumps in the data. We apply boudt2011robust's modified lee2007jumps's univariate jump test that accounts for intraday periodicity, on one-minute returns (at $\alpha = 0.1\%$) to identify jumps. The univariate tests identify 1,710 ETF jumps across 1,163 (jump) days. Some days include gradual or multiple ETF jumps.
There are many asynchronous jumps. We construct 1,529 [-5,+5]-minute jump-event matrices, around ETF jumps, as in equation (ref). When there are multiple ETF jumps within the event window, the event window spans from five minutes before the first ETF jump to five minutes after the last jump. We contrain the RLP in three ways. 1) Stocks that already jump with the index, cannot move, because we assume those are efficient. 2) No stock jumps may be moved earlier than the highly liquid and carefully watched ETF. 3) No stock jumps may be moved if the ETF jumps within the first 10 minutes or the last 10 minutes of the trading day. After imposing these filters, there remain 380 matrices candidate for rearrangement. The RLP rearranges stock jumps in {$180$} cases (or 11.8% of all jump-event matrices).
We investigate sluggish cojumps, i.e. jumps that occur later than the index (futures) jumps in the DIA. Consider the following example: on September 18, 2007 the Federal Reserve announced rate cuts, a bold but risky action according to the financial press. \footnote{ The \href{https://www.federalreserve.gov/newsevents/pressreleases/monetary20070918a.htm}{Press release} and the related \href{https://www.federalreserve.gov/monetarypolicy/files/FOMC20070918meeting.pdf}{FOMC Meeting Statement}. See also the coverage in The Economist and the Financial Times: \href{https://www.economist.com/node/9833657/print?story_id=9833657}{Bernanke's bounty}, \href{https://www.ft.com/content/c91d7af4-6610-11dc-9fbb-0000779fd2ac}{Instant reaction: Response to the Fed}, \href{https://www.ft.com/content/8171a091-0790-3907-a9b7-511e36029587}{The Short View: Fed decision — it’s all about game theory}, \href{https://www.ft.com/content/0c92f198-661a-11dc-9fbb-0000779fd2ac}{Overview: US equities and oil surge after rate cuts}, \href{https://www.ft.com/content/116ef120-662f-11dc-9fbb-0000779fd2ac}{Cheering greets Fed announcement}, \href{https://www.ft.com/content/9c0a6592-6b81-11dc-863b-0000779fd2ac}{Fed must weigh inflation against recession}, \href{https://www.ft.com/content/782afd5c-662d-11dc-9fbb-0000779fd2ac}{Bold Fed goes for half-point cut}, \href{https://www.ft.com/content/d45efd50-6635-11dc-9fbb-0000779fd2ac}{Bank acts boldly to avert recession risk}, \href{https://www.ft.com/content/b8220180-501b-3e8d-b440-6aaa0d2c2d93}{Fed cut: Pundits speak}, \href{https://amp.ft.com/content/3fb31ed0-6634-11dc-9fbb-0000779fd2ac}{Fed slashes rates}, and \href{https://www.ft.com/content/79ba05a4-4386-3bc2-aa44-205ea3f5f0ef}{Feeling ecstatic? Mind the e-Ben-der} }
Figure (ref) shows the price paths of the DIA ETF and a synthetic Dow 30 index and the spread between the returns of those two assets (ref) on the day of the FOMC Statement -- September 27, 2008. lee2007jumps's jump test flags a jump at 2:16 pm, one minute after the release of the statement. We mark the ETF jump with a red circle. The ETF price jumps $0.938\%$ at 14:16, U.S. Eastern Time, one minute after the release. As noted before, if news reached the entire market instantly, was interpreted homogeneously, and trading were continuous, jumps in a group of stocks should presumably occur simultaneously with the ETF index jump and spreads should be small and random. The ETF-synthetic index spread temporarily expand, however, following the ETF jump, and then contract again. That is, markets took time to incorporate the Fed's news into the Dow 30 stock's prices.
A jump-event matrix (ref) characterizes the asset jumps across an event window from five minutes before to five minutes after the index jump. On Sep. 18, 2007, for example, the event window contains 50 stock jumps, including many gradual jumps, from 30 stocks, of which $27$ match, i.e. occur at the same time as, the ETF jump and $23$ lag the ETF jump.
Figure (ref) shows the best rearrangement of the stock jumps for this event. By “best rearrangement," we mean the jump arrangement that minimizes the range of the spreads. The figure shows the range of the return spreads (left scale, gray) and the number of {matched stocks} (right scale, black) as a function of the permitted length of the move in time for each individual jump, as in equation (ref). The range declines as we permit {larger moves in time} and it is the criterion that determines the chosen number of backward moves for jumps. Permitting each jump to move one minute backward minimizes the range (orange line); the range drops from 0.427% to 0.227%. Permitting a maximum backward repositioning length of 4 periods or 4 minutes (green line) has the same minimal range for a larger number of matching stocks. This rearrangement matches $19$ out of $23$ scattered stock jumps with the ETF jump, approximately recovering the common jump in the stocks.
Recovering the common jump is likely to improve estimates of the daily realized covariance matrix. The realized covariance matrix is defined as barndorff2004econometric:
in which, ${Y}_{i\Delta_n} = (Y_{1,\Delta_n}, ..., Y_{p,\Delta_n})^\top$ is the observed log price process (ref) of the $p$ stocks sampled on a regular time grid $\{i\Delta_n: 0 \leq i \leq \floor{T/\Delta_n} \}$ over one day $T = 1$, the $i$th return of ${Y}_{i\Delta_n}$ is $\Delta_i^n {Y} = {Y}_{i\Delta_n} - {Y}_{(i-1)\Delta_n}$. The standard realized covariance matrix (ref) plugs in raw returns. Other estimators, like the multivariate realized kernel in barndorff2011multivariate or a Cholesky factorization in boudt2017positive, protect against mild market microstructure noise and the epps1979comovements effect, that is, the downward bias in covariance estimates due to asynchronous trading. Using rearranged returns in (ref) also protects against asynchronous jumps and the underestimation of jump dependence.
Figure (ref) allows us to visually compare covariance estimates made with raw vs. rearranged returns. It suggests that optimally changing the time labels of one of two observations (out of the 390 one-minute returns required to estimate the realized covariance) changes the estimated covariance structure between the stocks and the ETF returns on the day of the FOMC statement. For example, the fact that the statistics in the left panel generally lay above the 45-degree line shows that rearranging the jumps of HPQ, which jumps gradually, increases its variance and most covariance with other stocks. The right panel shows that rearranging the jumps of PFE, which jumps with an overreaction, reduces its own variance and all the covariances with PFE returns.
A practical question is whether one should use either raw returns or rearranged returns. Our recommendation is to always use the rearranged returns. These synchronized returns are more precise in a high-frequency analysis of market reactions around jumps.
We show the usefulness of using rearranged returns, compared to using raw returns, in the context of portfolio allocation, which shows that high-frequency rearranged jump returns affect the performance of low-frequency decisions, like building a daily-rebalanced minimum-variance portfolio.
Stock returns determine the weights that minimize the portfolio variance. The optimal weights for a particular day minimize the portfolio variance, subject to the constraints that they deliver a given expected return and that they sum to one markowitz52:
in which {$\sigma_{p,d}^2$} is the daily variance of the portfolio return, ${w}_d = (w_{1,d}, ..., w_{p,d})^\top$ is the daily $p$-dimensional weight vector, $C_d$ is the daily realized covariance matrix and $\mu_{p,d}$ is the {target} portfolio return. We make a grid of 100 target returns that range from the lowest average stock return to the highest one. To test our synchronization procedure, compare a simulated portfolio’s performance using raw vs. rearranged returns to compute the realized covariance matrix.
We optimize weights (ref) on rearrangement days, i.e. the 184 ETF jump days for which we rearrange jumps and rebalance the portfolio the next day. We keep those weights until the next rearrangement day. In those cases when the Dow constituency changes in between rearrangement days, we reset to an equally weighted portfolio until the next rearrangement day.
Table (ref) reports the portfolios' closing value, standard deviation and {modified} Sharpe ratio at the 5% level and the $p$-value of their difference ardia2015testing for the full sample and for each year. For {12 of 14} years and over the whole sample, the rearranged-return portfolio statistics are superior to the raw-returns portfolio statistics in terms of the modified Sharpe ratio. Over the full sample, the modified Sharpe ratios are significantly different and the rearranged-return portfolio delivers an additional 5% performance.
\if10 {\textcolor{darkblue}{The added value of rearranging returns is small.}} \fi
Stock prices often react sluggishly to news, producing gradual jumps and jump delays. The spread between the ETF price and the price of a synthetically constructed index measures the collective misalignment of noisy stock prices with their respective equilibrium levels. We introduce tools to synchronize the scattered jumps in a jump-event matrix and better approximate the efficient common jump. The rearrangement is currently very practical for problems with up to 30 stocks. We are working on a block rearrangement to allow for larger dimensions and, for example, synchronize stock jumps in the S&P500 index.
Estimating realized covariance matrices with these synchronized stock returns, as opposed to using raw returns, improves out-of-sample portfolio performance. Recovering the common jump on a fine sampling grid is likely to improve other asset allocation and risk management decisions, like estimating the jump size distribution boudt2011outlyingness, estimating jump dependence \citep*[see e.g.,][]{li2017mixed,li2017jump,li2019rank} or forecasting realized measures (see e.g., andersen2007roughing, andersen2007roughing; bollerslev2020realized bollerslev2020realized; bollerslev2022realized, bollerslev2022realized). A thorough analysis must, however, await future work.