The Moment Markets Stopped Making Sense
On August 21, 2007, at 2:00 PM ET, a group of hedge fund managers gathered at the New York Federal Reserve received a phone call that no one could explain. The Federal Reserve had just injected $38 billion into the banking system to prevent a credit market seizure. For quant funds running convergence strategies, the signal was clear: something had broken. But what followed was stranger still. Within 90 minutes, the prices of the most liquid, closely tracked securities in the world diverged from their models in ways that should have been statistically impossible. Long/Short equity funds, merger arbitrage portfolios, and convertible bond strategies all collapsed simultaneously. The models said buy. The market said run.
This was not a single fund failing. This was a systemic unraveling of quantitative logic itself.
The same pattern repeats across decades. Long-Term Capital Management in 1998. The August 2007 quant quake. The March 2020 circuit breaker cascade. In each case, the brightest minds in finance—PhD physicists, Nobel economists, former options market makers from the CBOE—built systems that worked flawlessly until the moment they catastrophically did not.
The question this article examines is not "what happened" but "why did it keep happening?" The answer lies in three interlocking forces: leverage, liquidity枯竭 (liquidity depletion), and model homogenization. Understanding these forces does not guarantee immunity from the next collapse, but it does provide a framework for building strategies that degrade gracefully rather than blow up catastrophically.
Long-Term Capital Management: The Quants Who Knew Too Much
2.1 The Setup
Long-Term Capital Management was founded in 1994 by John Meriwether, a former Salomon Brothers vice chairman, and built around a roster of academic luminaries that included Myron Scholes (Nobel Prize in Economics, 1997) and Robert Merton (Nobel Prize in Economics, 1997). The fund's core strategy was convergence trading: identify securities that had temporarily diverged from their theoretically justified prices, bet that they would reconverge, and collect the premium for bearing that convergence risk.
The strategy worked spectacularly. LTCM returned 21% in its first year, 43% in its second, and had grown to manage $7 billion in equity with borrowed capital pushing total assets under management toward $130 billion. At its peak, LTCM's leverage ratio exceeded 30:1.
The convergence trades LTCM favored required low-volatility environments. When volatility rises, the models demand wider stop-losses or forced liquidation. When liquidity dries up, the "convergence" trade cannot exit even if it is correct. LTCM's edge depended on markets behaving the way models expected them to behave—most of the time.
2.2 The Collapse
The trigger was the 1998 Russian debt default and the subsequent devaluation of the ruble. This was not a surprise to any macro trader. What was surprising was the market's response: the correlation between previously uncorrelated assets spiked sharply. Government bonds, emerging market debt, corporate bonds, and even equities began falling simultaneously. The diversification benefit that LTCM's models had assumed was structural, not statistical, evaporated within days.
On August 21, 1998, LTCM lost $553 million—its largest single-day loss. By August 31, it had lost $1.85 billion in equity. The Federal Reserve Bank of New York convened an emergency meeting with major banks, warning that LTCM's failure could destabilize the entire financial system. The fund was eventually wound down, with initial investors recovering approximately 90 cents on the dollar—but only after a massive government-organized bailout.
2.3 The Lesson: Leverage Amplifies Everything
LTCM's failure was not primarily a model failure. Their models were broadly correct about long-term value. The fatal variable was leverage. A 30:1 leverage ratio means that a 3.3% adverse move in portfolio value wipes out the equity cushion entirely. In normal markets, LTCM's trades converged before hitting that threshold. When correlation broke and liquidity evaporated, the model was right but the fund was dead before the thesis could play out.
The critical insight: leverage transforms a probabilistic edge into a deterministic outcome during tail events. The tail event is not the risk—the inability to survive the tail event is the risk.
The August 2007 Quant Quake: When Models Met Their Shadow
3.1 The Catalyst
On August 9, 2007, BNP Paribas froze three investment funds that held US residential mortgage-backed securities. The French bank cited "a complete evaporation of liquidity" in the subprime mortgage market. This was the opening shot of what quant researchers later called the "August 2007 liquidity event"—a four-day period in which the correlation structure of global markets underwent a sudden and violent regime change.
For systematic equity long/short funds, this should have been a non-event. Long/short strategies are market-neutral by design—the long book and short book should hedge each other, leaving the fund indifferent to directional market moves. The problem was that the models assumed independence between the long book and the short book. During the August 2007 freeze, that independence collapsed.
3.2 The Correlation Breakdown
In normal market conditions, the following relationships held:
| Relationship | Normal Correlation | August 2007 Correlation |
|---|---|---|
| Long book vs. market direction | Near zero | −0.31 |
| Short book vs. market direction | Near zero | +0.44 |
| Long book vs. short book | Near zero | +0.78 |
| Convertible bond vs. underlying equity | 0.65 | 0.92 |
The near-zero correlation between longs and shorts—a cornerstone assumption of long/short risk models—turned positive and large. A strategy that was theoretically market-neutral was suddenly directionally exposed. When quant funds discovered this simultaneously, they all began reducing risk at the same time, amplifying the very moves that triggered the reduction.
This is the feedback loop that researchers at the time called the "quant quake":
- Market dislocates
- Models flag unusual correlation changes
- Quant funds reduce exposure simultaneously to match model mandates
- Reducing exposure amplifies market dislocations
- Amplified dislocations trigger more model-driven selling
- Repeat until a stabilizing event or capital exhaustion
3.3 The Convergence Trade Reversal
A subset of quant funds—the merger arbitrage and convertible bond arb strategies—faced a different but related problem. These strategies are essentially long volatility in disguise. They profit when deals close and lose when deals break. When credit markets seized in August 2007, the implied cost of carry on merger arbitrage positions exploded. Funds holding these positions had to post margin calls. The correct trade—holding through the dislocation—was impossible to execute because capital constraints forced liquidation.
The lesson from August 2007 is subtle but critical: model assumptions about market structure are themselves market-sensitive. When a large fraction of market participants use similar models, those models become part of the market structure they describe. The assumptions that make the model profitable also make the model fragile to collective adoption.
March 2020: The Liquidity Mirage
4.1 The Circuit Breaker Cascade
On March 9, 2020, the S&P 500 triggered a Level 1 circuit breaker within four minutes of the opening bell. Trading halted for 15 minutes. This was the first time the mechanism had been activated since 1997. On March 12, it triggered again—then again on March 16, when the S&P 500 opened down 9.5%. The circuit breaker worked as designed: it paused panic selling to allow the market to find price equilibrium. The problem was that when trading resumed, the imbalance was worse.
The mechanism that should have restored liquidity instead revealed how fragile liquidity had become. The bid-ask spread on SPY, the most heavily traded security in the world, widened from its normal $0.01 to $0.15 or more during peak volatility. Market depth at the best bid and ask dropped by 80%. Large institutional orders were being executed at prices 2–3% worse than the quoted price—a phenomenon called market impact that quant models had historically underestimated.
4.2 The VIX Spike and Volatility Targeting
The VIX, which measures implied volatility on S&P 500 options, spiked from 15 to 82 in 22 trading days—the fastest volatility expansion in recorded history. This created a cascading effect across volatility-targeting strategies, which maintain constant risk exposure by adjusting position size inversely with realized volatility.
When realized volatility spikes, volatility-targeting models automatically reduce position sizes. This is the correct response for an individual fund managing its own risk. But when 60% of systematic funds are running volatility-targeting strategies—a reasonable estimate for 2020—the collective effect is a synchronized reduction in demand for risk assets. The selling pressure from vol-targeting deleveraging exceeded the buying from value-oriented investors who saw cheap prices.
The market was not inefficient. The market was rational for the incentives each participant faced. The problem was that the aggregation of individually rational actions produced a collectively irrational outcome.
4.3 The Liquidity Illusion
The deepest lesson of March 2020 is the distinction between normal-time liquidity and stress-time liquidity. In normal conditions, markets exhibit what practitioners call "depth"—the ability to absorb large orders without significant price impact. This depth is not structural. It is maintained by market makers, statistical arbitrageurs, and high-frequency traders who provide liquidity because they profit from the bid-ask spread.
When volatility spikes, the economics of market making deteriorate. Wider spreads, faster price moves, and higher inventory risk mean that the market makers who provide normal-time liquidity are the first to withdraw when conditions become stressful. The result is a sudden, discontinuous collapse in available liquidity—not a gradual reduction.
| Metric | February 2020 (Normal) | March 2020 (Stress) |
|---|---|---|
| SPY bid-ask spread (avg) | $0.01 | $0.08–0.15 |
| SPY market depth at BBO | ~50,000 shares | ~5,000–10,000 shares |
| Treasury bond basis | 2–5 bps | 15–40 bps |
| Investment-grade credit OAS | 120 bps | 350 bps+ |
| Equity vol (VIX) | 15–20 | 82 (peak) |
The critical error in many quant models is treating liquidity as a constant or as a function of volatility. In reality, liquidity has a binary quality: it is abundant until it suddenly is not, and the transition is discontinuous and self-reinforcing.
The Anatomy of a Quant Collapse: Three Structural Forces
Across LTCM, August 2007, and March 2020, three structural forces appear in every case. These forces are not bugs in the system—they are features of how modern markets work. Understanding them is the prerequisite for building strategies that survive.
5.1 Leverage: The Great Multiplier
Leverage is the primary amplifier of quant failures. The mechanics are straightforward: borrowed capital multiplies both gains and losses. What makes leverage dangerous in quant strategies is the interaction with margin requirements and forced liquidation.
When a portfolio loses value, brokers require additional margin. In a stressed market, the very conditions that cause portfolio losses—widening spreads, falling prices, rising correlation—also trigger margin calls. The fund must liquidate to meet margin. Liquidating in a stressed market amplifies the price moves that caused the losses. The cycle accelerates until either the fund runs out of capital, the market stabilizes, or external intervention breaks the cycle.
The leverage problem has a structural solution: stress testing against maximum adverse moves during historical liquidity events. A strategy that can survive a 5-standard-deviation move in correlation, a 90% drop in market depth, and a 3x expansion in bid-ask spreads is not necessarily more profitable—but it is still alive when others are not.
5.2 Liquidity Depletion: The Invisible Floor That Vanishes
In normal conditions, liquidity is provided by a complex ecosystem of market participants: designated market makers, statistical arbitrageurs, internalizers, and retail flow. Each of these participants has a risk appetite that varies with market conditions. When conditions deteriorate, risk appetite contracts simultaneously across participant types, and liquidity dries up faster than any single model can predict.
The key property of liquidity depletion is its endogeneity: low liquidity causes more selling, which causes more low liquidity. The feedback loop is self-reinforcing and has no obvious floor. In March 2020, the Federal Reserve had to intervene directly in Treasury and corporate bond markets—the most liquid markets in the world—to break the feedback loop.
For quant strategy design, the practical implication is that liquidity risk cannot be modeled as a function of volatility alone. It must be modeled as a function of market structure, participant composition, and the behavior of specific market-maker archetypes under stress.
5.3 Model Homogenization: The Correlation of Crowds
Perhaps the most underappreciated force in quant collapses is model homogenization. When a strategy type becomes profitable—long/short equity in the 2000s, merger arbitrage in the 1990s, vol-targeting in the 2010s—capital flows into that strategy class. More capital means more participants running similar models. More participants running similar models means the assumptions encoded in those models become self-fulfilling in normal times and collectively dangerous in stressed times.
During the August 2007 quant quake, funds running convergence trades converged on the same positions because their models identified the same dislocations. When the dislocation widened, they all reduced risk simultaneously. The collective action amplified the very dislocations they had identified.
Model homogenization is difficult to measure and impossible to hedge directly. The most practical defense is position sizing that accounts for crowded trades—reducing size when crowded conditions are detected and accepting lower returns in exchange for lower tail risk.
Risk Management Architecture: Building for Survival
The preceding sections describe what goes wrong. This section describes what to build.
6.1 Position Sizing Under Stress
The Kelly Criterion provides an optimal growth-maximizing position size under ideal conditions. Real-world implementation requires three modifications:
- Half-Kelly or fractional Kelly: Reduce the Kelly fraction to account for estimation error in win rate and average return inputs.
- Volatility scaling: Adjust position size inversely with realized volatility, with a floor that prevents size from going to zero.
- Stress-based drawdown limits: Define a maximum drawdown that triggers forced position reduction regardless of current P&L.
The following implementation demonstrates a volatility-scaled position sizing system with stress-based drawdown controls:
import os
import time
import logging
import numpy as np
from datetime import datetime, timedelta
from collections import deque
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s | %(levelname)s | %(message)s"
)
logger = logging.getLogger(__name__)
class VolatilityScaledRiskManager:
"""
Position sizing engine with volatility scaling and stress-based drawdown controls.
Designed to prevent the leverage amplification failures seen in LTCM (1998),
the August 2007 quant quake, and March 2020 circuit breaker cascades.
Key design principles:
- Fractional Kelly sizing with volatility scaling
- Real-time drawdown monitoring with forced reduction triggers
- Stress mode activation when market microstructure signals break down
"""
def __init__(
self,
base_kelly_fraction: float = 0.25, # Half-Kelly as baseline
target_volatility: float = 0.15, # 15% annualized target volatility
max_drawdown_pct: float = 0.20, # 20% max drawdown triggers reduction
stress_mode_threshold: float = 0.40, # 40% vol expansion activates stress mode
stress_reduction_factor: float = 0.50, # 50% position reduction in stress mode
lookback_window: int = 252, # 1 trading year for vol estimation
min_volatility: float = 0.05, # Floor prevents infinite position sizing
):
self.base_kelly_fraction = base_kelly_fraction
self.target_volatility = target_volatility
self.max_drawdown_pct = max_drawdown_pct
self.stress_mode_threshold = stress_mode_threshold
self.stress_reduction_factor = stress_reduction_factor
self.lookback_window = lookback_window
self.min_volatility = min_volatility
self.equity_curve = deque(maxlen=lookback_window)
self.high_water_mark = 0.0
self.stress_mode_active = False
self.current_position_fraction = 1.0
logger.info(
f"Initialized VolatilityScaledRiskManager | "
f"Kelly={base_kelly_fraction:.2f} | "
f"TargetVol={target_volatility:.2%} | "
f"MaxDD={max_drawdown_pct:.2%}"
)
def update_equity(self, current_equity: float, timestamp: datetime) -> None:
"""Record equity value and update high water mark."""
self.equity_curve.append({"equity": current_equity, "timestamp": timestamp})
if current_equity > self.high_water_mark:
self.high_water_mark = current_equity
logger.info(
f"[{timestamp.isoformat()}] New high water mark: ${current_equity:,.2f}"
)
def compute_realized_volatility(self) -> float:
"""
Estimate annualized realized volatility from equity curve returns.
Uses log returns for statistical consistency.
"""
if len(self.equity_curve) < 20:
logger.warning(
f"Insufficient data for vol estimation ({len(self.equity_curve)} points). "
"Using default minimum volatility."
)
return self.min_volatility
equities = np.array([e["equity"] for e in self.equity_curve])
log_returns = np.diff(np.log(equities))
annualized_vol = float(np.std(log_returns)) * np.sqrt(252)
# Enforce floor to prevent infinite position sizing
annualized_vol = max(annualized_vol, self.min_volatility)
logger.debug(
f"Realized volatility: {annualized_vol:.2%} "
f"(from {len(log_returns)} daily returns)"
)
return annualized_vol
def check_drawdown(self, current_equity: float) -> float:
"""
Calculate current drawdown from high water mark.
Returns drawdown as a fraction (0.0 = no drawdown, 0.30 = 30% drawdown).
"""
if self.high_water_mark <= 0:
return 0.0
drawdown = (self.high_water_mark - current_equity) / self.high_water_mark
return max(0.0, drawdown)
def assess_stress_conditions(self, current_vol: float) -> bool:
"""
Determine whether market microstructure signals suggest stress conditions.
In stress mode (triggered by elevated volatility), position sizes are
mechanically reduced. This addresses the liquidity withdrawal pattern
observed in March 2020 and August 2007.
Note: For production use, supplement this heuristic with direct liquidity
metrics (bid-ask spread, market depth) sourced from a data provider.
A practical implementation would fetch these from TickDB's depth channel
for the relevant symbol and monitor L1 spread expansion.
"""
vol_ratio = current_vol / self.target_volatility
if vol_ratio > self.stress_mode_threshold:
if not self.stress_mode_active:
logger.warning(
f"STRESS MODE ACTIVATED | Vol ratio: {vol_ratio:.2f}x | "
f"Reducing positions by {self.stress_reduction_factor:.0%}"
)
self.stress_mode_active = True
return True
else:
if self.stress_mode_active:
logger.info(
f"Stress conditions easing | Vol ratio: {vol_ratio:.2f}x | "
"Resuming normal sizing"
)
self.stress_mode_active = False
return False
def compute_target_position_fraction(self) -> float:
"""
Calculate the Kelly-optimal position fraction adjusted for volatility
scaling and stress conditions.
The core formula: fractional_kelly * (target_vol / realized_vol)
This ensures that position sizes automatically shrink when the market
becomes more volatile—the key mechanism that prevents the leverage
amplification observed in LTCM and the vol-targeting cascade of March 2020.
"""
current_vol = self.compute_realized_volatility()
self.assess_stress_conditions(current_vol)
# Volatility-scaled Kelly position
vol_adjusted_fraction = (
self.base_kelly_fraction
* (self.target_volatility / current_vol)
)
# Apply stress mode reduction
if self.stress_mode_active:
vol_adjusted_fraction *= self.stress_reduction_factor
# Enforce floor and ceiling
vol_adjusted_fraction = np.clip(vol_adjusted_fraction, 0.0, 1.0)
self.current_position_fraction = vol_adjusted_fraction
logger.info(
f"Target position fraction: {vol_adjusted_fraction:.2%} | "
f"Stress mode: {self.stress_mode_active} | "
f"Realized vol: {current_vol:.2%}"
)
return vol_adjusted_fraction
def check_forced_reduction(self, current_equity: float) -> bool:
"""
Trigger forced position reduction if drawdown exceeds threshold.
This addresses the margin call cascade that destroyed LTCM and
forced liquidation across quant strategies in August 2007.
Returns True if forced reduction is triggered.
"""
current_drawdown = self.check_drawdown(current_equity)
if current_drawdown > self.max_drawdown_pct:
logger.critical(
f"MAX DRAWDOWN EXCEEDED | Current: {current_drawdown:.2%} | "
f"Threshold: {self.max_drawdown_pct:.2%} | "
"Initiating forced position reduction"
)
self.current_position_fraction *= self.stress_reduction_factor
return True
return False
def get_risk_report(self, current_equity: float) -> dict:
"""
Generate a comprehensive risk status report.
This output is suitable for dashboard integration, alerting, or
automated risk management workflows.
"""
current_vol = self.compute_realized_volatility()
current_drawdown = self.check_drawdown(current_equity)
vol_ratio = current_vol / self.target_volatility
return {
"timestamp": datetime.now().isoformat(),
"current_equity": current_equity,
"high_water_mark": self.high_water_mark,
"current_drawdown_pct": round(current_drawdown, 4),
"realized_volatility": round(current_vol, 4),
"vol_ratio_to_target": round(vol_ratio, 2),
"stress_mode_active": self.stress_mode_active,
"target_position_fraction": round(self.current_position_fraction, 4),
"forced_reduction_triggered": current_drawdown > self.max_drawdown_pct,
}
# ⚠️ Engineering warning: This implementation is a foundational reference.
# For production deployment, extend it with:
# - Direct liquidity metrics from TickDB depth channel (spread, market depth)
# - Multi-asset correlation estimation for portfolio-level risk
# - Regime detection (hidden Markov models or similar)
# - Integration with broker margin APIs for real-time margin monitoring
# - Asynchronous data ingestion for low-latency position updates
if __name__ == "__main__":
# Simulation demonstrating stress mode activation and drawdown management
np.random.seed(42)
manager = VolatilityScaledRiskManager()
equity = 1_000_000.0
# Simulate 252 days: normal volatility (150 days) then stress (102 days)
normal_returns = np.random.normal(0.0003, 0.01, 150) # ~15% annual vol
stress_returns = np.random.normal(-0.002, 0.03, 102) # ~48% annual vol
all_returns = np.concatenate([normal_returns, stress_returns])
for i, daily_return in enumerate(all_returns):
equity *= (1 + daily_return)
manager.update_equity(equity, datetime.now() + timedelta(days=i))
if manager.check_forced_reduction(equity):
pass # In production: trigger position reduction via broker API
if i % 50 == 0:
report = manager.get_risk_report(equity)
logger.info(
f"Day {i:3d} | Equity: ${equity:>12,.2f} | "
f"DD: {report['current_drawdown_pct']:.2%} | "
f"Vol: {report['realized_volatility']:.2%} | "
f"Stress: {report['stress_mode_active']} | "
f"PosFrac: {report['target_position_fraction']:.2%}"
)
The system above implements three layers of protection that were absent or inadequate in each historical collapse:
- Volatility scaling: Position sizes automatically reduce when markets become more volatile. This prevents the leverage amplification that destroyed LTCM.
- Stress mode: A separate mechanism that further reduces exposure when volatility expansion signals structural breakdown. This addresses the liquidity withdrawal pattern of March 2020.
- Forced drawdown reduction: When the portfolio hits a predefined drawdown threshold, position sizes are mechanically reduced. This prevents the death-spiral of margin calls and forced liquidation seen in August 2007.
Five Defenses Against the Next Collapse
7.1 Know Your Correlation Assumptions
Every long/short strategy embeds implicit correlation assumptions. These assumptions should be stated explicitly and stress-tested against correlation regimes that did not exist in the training data. In particular, test the strategy's behavior when the long book and short book correlation moves from −0.1 to +0.5 or higher.
7.2 Model for Liquidity Discontinuously
Liquidity does not degrade linearly. It has a cliff edge. Build models that assume liquidity is available at current prices up to a threshold, then drops to a small fraction of normal volume beyond that threshold. Do not model liquidity as a smooth function of volatility.
7.3 Size Positions for the Worst-Case Crowded Exit
If a position is crowded—if many other funds hold similar views—assume that the exit will be worse than the model predicts. Apply an additional haircut to expected liquidity at exit. This is the only direct defense against model homogenization risk.
7.4 Build for Graceful Degradation, Not Maximum Return
The strategies that survive tail events are not the ones with the highest Sharpe ratios. They are the ones that degrade gracefully—losing less than proportional to the market move, staying investable through the dislocation, and maintaining enough capital to deploy when conditions normalize.
7.5 Monitor the Things That Cannot Be Modeled
Market structure changes, regulatory shifts, and technological transitions create regime breaks that no historical backtest captures. Build monitoring systems for leading indicators of structural change: central bank policy direction, margin regulation updates, market microstructure changes, and the concentration of strategy types among major participants.
The Humility That Models Cannot Compute
The thread connecting LTCM, August 2007, and March 2020 is not mathematical. It is philosophical. The models were not wrong—they were incomplete. They captured the central tendency of market behavior under normal conditions. They did not capture the conditional probability that their own adoption had changed the market structure they were modeling.
This is not a solvable problem. It is a permanent condition of operating in markets. Every quant strategy runs in a market that its own trading has modified. The models that ignore this feedback loop are not wrong in the short term—they are often quite profitable. They are wrong in the long term, because the conditions under which they are profitable are also the conditions that make them most dangerous.
The defense is not a better model. The defense is a better architecture: position sizing that accounts for leverage, liquidity modeling that assumes discontinuity, correlation stress testing that is not limited to historical regimes, and risk management that degrades gracefully rather than崩塌 catastrophically.
The market is not a machine. It is a collective of human and algorithmic agents, each optimizing for their own objectives, each constrained by their own liquidity and leverage limits, each influenced by the others' actions in ways that are only partially observable. A model that respects this complexity—not by simulating every agent, but by building defenses against the failure modes that complexity guarantees—is the one that survives long enough to generate the returns that justify its existence.
Next Steps
If you are building systematic strategies and want access to clean, historical OHLCV data for robust backtesting, TickDB provides 10+ years of historical data across US equities, crypto, and other asset classes via a unified API. The /kline endpoint is suitable for historical strategy research, and the depth channel provides real-time order book context for live risk monitoring.
If you are a quant researcher or risk manager, review your current position sizing methodology against the three failure modes described in this article: leverage amplification, liquidity discontinuity, and model homogenization. The VolatilityScaledRiskManager class above provides a reference implementation; adapt it to your specific asset class and leverage profile.
If you are building a real-time risk monitoring system, consider installing the tickdb-market-data SKILL on ClawHub for low-latency access to order book depth and spread metrics—essential inputs for the liquidity monitoring layer that standard OHLCV-based systems lack.
This article does not constitute investment advice. Markets involve risk; past performance of any strategy—including those discussed in historical case studies—does not guarantee future results. Quantitative strategies carry specific risks including model risk, liquidity risk, and leverage-related drawdown risk. All backtests and simulations referenced in this article are illustrative and do not represent live trading results.