Speed of Light: c = 299,792,458 m/s ≈ 300,000 km/s

Latency = Distance / c

Example Distances:
- New York to Chicago: 1,140 km → 3.8 ms (one way)
- New York to London: 5,500 km → 18.3 ms (one way)
- New York to Tokyo: 10,800 km → 36.0 ms (one way)

In microseconds (μs):
- 1 km → 3.33 μs
- 100 km → 333 μs
- 1,000 km → 3.33 ms

Latency Spectrum:

┌─────────────────────────────────────────────────────────────────────┐
│                    Latency Spectrum                                │
│                                                                   │
│  Nanoseconds (10⁻⁹ s):                                          │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │  • FPGA clock cycles (1-10 ns)                           │   │
│  │  • Memory access (10-100 ns)                            │   │
│  │  • Network packet processing (100-1,000 ns)            │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                   │
│  Microseconds (10⁻⁶ s):                                        │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │  • Kernel bypass packet processing (1-10 μs)              │   │
│  │  • FPGA strategy execution (1-5 μs)                      │   │
│  │  • Colocated network round trip (10-50 μs)                │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                   │
│  Milliseconds (10⁻³ s):                                       │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │  • Standard network round trip (1-100 ms)                │   │
│  │  • OS kernel processing (100-1,000 μs)                   │   │
│  │  • Garbage collection latency (1-10 ms)                   │   │
│  └─────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────┘

Colocation Benefits:

1. Distance Reduction:
   - Without colocation: Server → Exchange (10-100 km)
   - With colocation: Server → Exchange (few meters)
   - Latency reduction: 0.03-0.3 ms → 0.0001 ms

2. Network Stability:
   - Dedicated fiber connections
   - Minimal jitter (variation in latency)
   - No shared network congestion

3. Direct Exchange Connectivity:
   - Direct access to exchange matching engines
   - Priority data feeds
   - Customized network routes

Kernel Bypass vs. Standard Networking:

┌─────────────────────────────────────────────────────────────────────┐
│                    Kernel Bypass vs Standard Networking           │
│                                                                   │
│  Standard Network Stack:                                        │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │  Network Packet → NIC → Kernel → System Call → User Space │   │
│  │                                                                   │
│  │  Latency: 50-100 μs (variable, high jitter)               │   │
│  │  Bottlenecks: System calls, context switches, kernel      │   │
│  │               processing                                   │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                   │
│  Kernel Bypass:                                                │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │  Network Packet → NIC → User Space (Direct Memory Access)  │   │
│  │                                                                   │
│  │  Latency: 1-5 μs (deterministic, low jitter)             │   │
│  │  Technologies: Solarflare OpenOnload, DPDK, RDMA         │   │
│  └─────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────┘

Memory Pool Example:

class MemoryPool {
private:
    char* pool;
    size_t pool_size;
    size_t current_offset;
    
public:
    MemoryPool(size_t size) {
        pool = new char[size];
        pool_size = size;
        current_offset = 0;
    }
    
    void* allocate(size_t size) {
        if (current_offset + size > pool_size) {
            return nullptr;  // Pool exhausted
        }
        void* ptr = pool + current_offset;
        current_offset += size;
        return ptr;
    }
};

Lock-Free Ring Buffer:

┌─────────────────────────────────────────────────────────────────────┐
│                    Lock-Free Ring Buffer                          │
│                                                                   │
│  Write Index ───────────────────────────────────►                 │
│  ┌────────┬────────┬────────┬────────┬────────┐                 │
│  │  Slot  │  Slot  │  Slot  │  Slot  │  Slot  │                 │
│  │   1    │   2    │   3    │   4    │   5    │                 │
│  ├────────┼────────┼────────┼────────┼────────┤                 │
│  │  Data  │  Data  │  Data  │  Data  │  Data  │                 │
│  │  ████  │  ████  │  ████  │  ████  │  ████  │                 │
│  └────────┴────────┴────────┴────────┴────────┘                 │
│                                                                   │
│  Read Index ───────────────────────────────────►                 │
│                                                                   │
│  Characteristics:                                              │
│  • No locks (atomic operations)                               │
│  • Pre-allocated memory                                       │
│  • Predictable latency                                        │
│  • High throughput (millions of messages/sec)                │
└─────────────────────────────────────────────────────────────────────┘

Cache-Aligned Structure:

struct alignas(64) OrderBookEntry {
    // 64-byte alignment ensures cache line
    int64_t price;
    int64_t quantity;
    int64_t order_id;
    int64_t timestamp;
    // ... other fields
};

Market Data Feeds:

1. Consolidated Feed:
   - Aggregated data from all exchanges
   - Higher latency (50-100 ms)
   - Lower cost

2. Direct Exchange Feed:
   - Raw data directly from exchange
   - Lower latency (1-5 ms)
   - Higher cost

3. Colocated Feed:
   - Direct feed via exchange colocation
   - Lowest latency (10-100 μs)
   - Highest cost

4. Raw Feed:
   - Full depth of order book
   - Highest data volume
   - Most detailed information

Market Data Parsing Pipeline:

1. Receive packet from NIC (DMA to user space)
2. Parse packet header (identify message type)
3. Extract timestamp (hardware timestamping)
4. Parse message payload:
   - Order Book Update (add, modify, delete)
   - Trade Report
   - Market Snapshot
   - Heartbeat
5. Validate message (checksum, sequence number)
6. Update internal state (order book, positions)
7. Execute trading logic
8. Generate orders
9. Send orders via NIC

FPGA Market Data Processing:

1. Market data arrives via fiber (10 Gbps)
2. FPGA captures packet directly
3. Hardware parsing of binary protocol
4. Hardware state update (order book in FPGA memory)
5. Hardware strategy evaluation
6. Hardware order generation
7. Hardware order transmission

Latency: 100 ns - 1 μs (10-100× faster than software)

Market Making Mechanics:

1. Quote simultaneous bid and ask:
   - Bid: Best bid - δ (slightly below market)
   - Ask: Best ask + δ (slightly above market)

2. Capture spread on each round-trip trade:
   - Profit = Ask_Price - Bid_Price - Transaction_Costs

3. Manage inventory risk:
   - If inventory long: widen bid, narrow ask
   - If inventory short: narrow bid, widen ask

4. Cancel and update quotes continuously:
   - Cancel rate: 90-99% of orders
   - Order-to-trade ratio: 50:1 to 500:1

Quote Setting:

Bid = Mid - Spread/2 - α × Inventory × σ
Ask = Mid + Spread/2 - α × Inventory × σ

Where:
- Mid = (Best_Bid + Best_Ask) / 2
- Spread = Base_Spread + β × Volatility
- α = Inventory risk aversion coefficient
- σ = Volatility of the asset
- Inventory = Current position (positive = long, negative = short)

Adjustments:
- If Inventory > 0: Lower bid (discourage buying), lower ask (encourage selling)
- If Inventory < 0: Raise bid (encourage buying), raise ask (discourage selling)

Inventory Risk Management:

1. Skew Quotes:
   - Long inventory: lower ask, lower bid (encourage selling)
   - Short inventory: raise bid, raise ask (encourage buying)

2. Hedge with Futures:
   - Hedge inventory with correlated futures
   - Reduces directional risk

3. Limit Position Size:
   - Maximum position limits
   - Stop-loss on large moves

4. Dynamic Spread Adjustment:
   - Increase spread when inventory grows
   - Decrease spread when inventory is balanced

Cross-Exchange Arbitrage Mechanics:

1. Asset trades on two exchanges: A and B
2. Price divergence occurs due to:
   - Order flow imbalance on one exchange
   - Latency differences (information arrives at one exchange first)
   - Liquidity differences

3. Arbitrage opportunity:
   - Buy on exchange A (cheaper)
   - Sell on exchange B (more expensive)
   - Profit = Price_B - Price_A - Transaction_Costs

4. The arbitrage converges:
   - Buying on A pushes price up
   - Selling on B pushes price down
   - Spread closes

Example: Apple stock (AAPL) on NASDAQ and BATS

Time: 10:00:00.000000
NASDAQ: $150.00
BATS: $150.00

Time: 10:00:00.000010
NASDAQ: $150.05 (large buy order arrives)
BATS: $150.00 (still stale)

Latency Arbitrage:
1. Buy on BATS: $150.00
2. Sell on NASDAQ: $150.05
3. Profit: $0.05 per share

Time: 10:00:00.000020
BATS: $150.05 (information propagates)
Spread closed

Competitive Dynamics:

1. Winner: First to act captures the spread
2. Loser: Others miss the opportunity

The race is determined by:
1. Network latency (colocation)
2. Hardware latency (FPGA vs. software)
3. Parsing speed (kernel bypass vs. OS stack)
4. Execution speed (lock-free vs. locks)
5. Order routing (direct vs. through broker)

The winner captures the arbitrage profit.
The losers incur costs (market data, colocation, hardware).

Momentum Ignition:

1. Trader places a large buy order
2. Momentum-following algorithms detect the order
3. They buy (anticipating further price increase)
4. Price moves up
5. Trader sells at the higher price
6. Profit captured

This strategy exploits momentum-following algorithms.

Quote Stuffing:

1. Trader sends thousands of orders per millisecond
2. Creates noise in the market data feed
3. Slows down competitors' processing
4. Gains a timing advantage

Characteristics:
- Order-to-trade ratio: 1,000:1 or higher
- Cancellation rate: 99.9%
- Short duration (milliseconds)
- Highly controversial

Sₜ = P₁,ₜ - γP₂,ₜ

If Sₜ is stationary, the assets are cointegrated.

Test for Cointegration (Engle-Granger):
1. OLS regression: P₁,ₜ = α + γP₂,ₜ + εₜ
2. ADF test on residuals εₜ
3. If residuals are stationary → cointegration

Interpretation:
- The series share a common stochastic trend
- Deviations from the long-term equilibrium are temporary
- The spread will mean-revert

Augmented Dickey-Fuller (ADF) Test:

Δyₜ = α + βt + γyₜ₋₁ + ΣδᵢΔyₜ₋ᵢ + εₜ

Hypotheses:
H₀: γ = 0 (unit root, non-stationary)
H₁: γ < 0 (no unit root, stationary)

Decision:
- If p-value < 0.05: Reject H₀ → Series is stationary
- If p-value ≥ 0.05: Fail to reject H₀ → Series is non-stationary

Variance Ratio Test:
- Compare variance of yₜ to variance of yₜ - yₜ₋₁
- If ratio ≈ 1: Random walk (non-stationary)
- If ratio < 1: Mean-reverting (stationary)

Ornstein-Uhlenbeck (OU) Process:

dSₜ = θ(μ - Sₜ)dt + σdWₜ

Where:
- θ = Mean reversion rate (speed of mean reversion)
- μ = Long-term mean
- σ = Volatility (diffusion coefficient)
- Wₜ = Standard Brownian motion (Wiener process)

Properties:
1. Mean: E[Sₜ] = μ
2. Variance: Var[Sₜ] = σ²/(2θ)
3. Correlation: Corr[Sₜ, Sₛ] = exp(-θ|t-s|)
4. Half-life: τ = ln(2)/θ (time to revert halfway)

Discretization:
Sₜ₊₁ = Sₜ + θ(μ - Sₜ)Δt + σ√Δt · ε

Where ε ~ N(0,1)

Estimating OU Parameters:

1. Run OLS regression: ΔSₜ = α + βSₜ₋₁ + εₜ
2. Where: α = θμ, β = -θ
3. θ = -β
4. μ = α/θ
5. σ = sd(εₜ) / √(Δt)

Alternative (MLE):
Maximize log-likelihood of the OU process.

Z-Score Calculation:

Zₜ = (Sₜ - μ_rolling) / σ_rolling

Where:
- μ_rolling = Rolling mean (lookback window, e.g., 20-100 periods)
- σ_rolling = Rolling standard deviation (same window)

Trading Rules:
┌─────────────────────────────────────────────────────────────────────┐
│  Z-Score Range        |  Action                                   │
│  Z > 2.0              |  Short the spread (sell overvalued asset) │
│  Z < -2.0             |  Long the spread (buy undervalued asset) │
│  |Z| < 0.5            |  Exit position (close trade)             │
└─────────────────────────────────────────────────────────────────────┘

Z-Score Trading Example:

Spread: Sₜ = P₁,ₜ - γP₂,ₜ

Lookback: 50 periods

Zₜ = 2.5 → Entry: Short spread
- Sell P₁ (overvalued)
- Buy γ × P₂ (undervalued)

Exit when Zₜ = 0.5 (or 0.0)
- Buy back P₁ (cover short)
- Sell γ × P₂ (close long)

Profit: Difference between entry and exit spread

Pairs Trading: Coca-Cola (KO) vs. PepsiCo (PEP)

Historical Relationship:
P_KO = 0.8 × P_PEP + ε

Cointegration Test:
ADF p-value: 0.015 → Cointegrated

Current:
P_KO = $70
P_PEP = $80
Spread = 70 - 0.8 × 80 = 70 - 64 = 6

Rolling Statistics (50 days):
μ_spread = 4.5
σ_spread = 1.5
Z-score = (6 - 4.5) / 1.5 = 1.0 (No trade)

After a few days:
P_KO = $72
P_PEP = $80
Spread = 72 - 64 = 8
Z-score = (8 - 4.5) / 1.5 = 2.33

Entry: Short spread
- Sell 100 shares of KO at $72
- Buy 80 shares of PEP at $80

Exit (when spread reverts):
P_KO = $70
P_PEP = $80
Spread = 70 - 64 = 6
Z-score = 1.0

Exit: Close positions
- Buy 100 shares of KO at $70
- Sell 80 shares of PEP at $80

Profit: ($72 - $70) × 100 = $200 (KO short)
+ ($80 - $80) × 80 = $0 (PEP long)
Total Profit: $200

Information Asymmetry:

Informed Traders:
- Possess private information
- Trade aggressively to profit
- Cause adverse selection for market makers

Uninformed Traders:
- No private information
- Trade for liquidity reasons
- Provide profit opportunity for market makers

Market Makers:
- Provide liquidity
- Capture spread
- Risk trading with informed traders

VPIN Calculation:

1. Define Volume Buckets:
   - Bucket size = V_bucket = V_T / n
   - Where V_T is total trading volume, n is number of buckets

2. For each bucket:
   - Classify trades as buyer-initiated or seller-initiated
   - Calculate imbalance: I = |Buy_Volume - Sell_Volume|

3. VPIN = Σ I / (n × V_bucket)

Interpretation:
- VPIN = 0: No imbalance (all trades are balanced)
- VPIN = 0.5: Moderate imbalance
- VPIN = 1.0: Extreme imbalance (highly toxic)

Higher VPIN → Higher probability of informed trading

VPIN Calculation Example:

Bucket Size: 10,000 shares
Total Volume: 100,000 shares
Number of Buckets: 10

Bucket 1: Buy=6,000, Sell=4,000, I=2,000
Bucket 2: Buy=3,000, Sell=7,000, I=4,000
Bucket 3: Buy=8,000, Sell=2,000, I=6,000
Bucket 4: Buy=4,500, Sell=5,500, I=1,000
Bucket 5: Buy=7,500, Sell=2,500, I=5,000

VPIN = (2,000 + 4,000 + 6,000 + 1,000 + 5,000) / (10 × 10,000)
VPIN = 18,000 / 100,000 = 0.18

Interpretation: Low toxicity (18%)

VPIN Risk Management:

VPIN < 0.3: Low toxicity
- Normal market making
- Normal quote widths

0.3 < VPIN < 0.5: Moderate toxicity
- Widen spreads
- Reduce position sizes
- More conservative quoting

VPIN > 0.5: High toxicity
- Pull liquidity (stop quoting)
- Aggressively hedge
- Risk-off mode

VPIN > 0.7: Extreme toxicity
- Cease market making entirely
- Liquidate positions
- Protect capital

Imbalance Ratio = (Buy_Volume - Sell_Volume) / (Buy_Volume + Sell_Volume)
- Positive: More buyers (upward pressure)
- Negative: More sellers (downward pressure)
- Extreme values indicate potential toxicity

Lee-Ready Algorithm:
1. If trade price > mid price: Buyer-initiated
2. If trade price < mid price: Seller-initiated
3. If trade price = mid price: Classify based on previous trade

Mid Price = (Best_Bid + Best_Ask) / 2

Order Book Imbalance:
OBI = (Bid_Volume - Ask_Volume) / (Bid_Volume + Ask_Volume)
- Positive: More bids than asks (buying pressure)
- Negative: More asks than bids (selling pressure)

VPIN Implementation:

1. Define time window: 1-5 minutes
2. Define bucket size: 50-100 shares (scaled to liquidity)
3. Process trades:
   a. Classify each trade (buy/sell)
   b. Add to current bucket
   c. If bucket is full:
      - Compute imbalance for bucket
      - Reset bucket
4. Compute VPIN = average imbalance

Real-time VPIN:
- Update with each trade
- Rolling window (e.g., 50 buckets)
- Compute continuous VPIN stream

VPIN Applications:

1. Market Making:
   - Adjust quotes based on toxicity
   - Pull liquidity when VPIN is high

2. Algorithmic Execution:
   - Reduce order size when toxicity is high
   - Use passive orders in toxic markets

3. Risk Management:
   - Reduce position sizes
   - Hedge more aggressively

4. Strategy Selection:
   - Switch to momentum strategies in high toxicity
   - Switch to mean reversion in low toxicity

VPIN During a Flash Crash:

Normal Market:
- VPIN: 0.15-0.25 (low toxicity)
- Market making normal
- Spread: 1-2 ticks

Pre-Crash:
- VPIN: 0.35-0.45 (moderate toxicity)
- Some informed selling
- Spread: 2-3 ticks

Crash:
- VPIN: 0.65-0.85 (high toxicity)
- Heavy informed selling
- Market making pulled (spread widens to 10+ ticks)

Post-Crash:
- VPIN returns to 0.15-0.25
- Market making resumes
- Spread normalizes

Lesson: VPIN can provide early warning of toxic flow.