Learn about slippage assumptions

6.2.6 · Stock-Market › Backtesting Frameworks

Slippage Kya Hai?

YEH KYUN hoti hai: Markets infinitely liquid nahi hote. Bade orders har price level par available liquidity consume kar lete hain, jo baad ke fills ko worse prices par force karta hai. Chhote orders bhi bid-ask spread face karte hain—jo ek guaranteed minimum slippage hai.

YEH KAISE dikhti hai: Tum tab buy karne ka decide karte ho jab price $50.00(mid-market)ho.Jabtaktumharaorderpahunchtahai,ask$50.05 ho jaata hai. Tumhara fill $50.05parhotahai.Slippage=$0.05 = 10 basis points.

Slippage Models ko First Principles se Derive Karna

1. Fixed Slippage Model

Assumption: Har trade ek constant slippage $s$ pay karta hai (basis points mein ya absolute dollars mein).

Derivation:

• Buy karte waqt expected fill price: $P_{\text{fill}}=P_{\text{decision}}\times (1+s)$
• Sell karte waqt expected fill price: $P_{\text{fill}}=P_{\text{decision}}\times (1-s)$

YEH FORM KYUN? Yeh sabse simple model hai: average market conditions assume karta hai aur volatility, order size, aur liquidity variations ko ignore karta hai.

Example: Buy 100 shares at $50,$s = 0.001$ (10 bps)

• Expected fill: $50\times 1.001=50.05$
• Slippage cost: 100 \times 50 \times 0.001 = \5$

Yeh step kyun? Price se multiply karne par basis points dollars mein convert ho jaate hain. Absolute value $|Q|$ ensure karta hai ki slippage hamesha ek cost ho, kabhi gain nahi. Conversion dhyaan se karo: 5 bps $0.0005$ hai (na ki $0.005$)—yahaan ek factor-of-10 ki galti silently tumhare costs ko tenfold inflate kar deti hai.

2. Volume-Dependent Slippage Model

Assumption: Average volume ke relative bade orders zyada worse slippage experience karte hain.

Market microstructure se Derivation:

• Order book mein har price level $P_i$ par depth $D_i$ hoti hai
• Tumhara order $Q$ book ko walk up karta hai, liquidity consume karta hai
• Average fill price consumed levels ka volume-weighted average hota hai

Average volume $V$ wale market mein size $Q$ ke market order ke liye: $\text{Market Impact}\propto \sqrt{\frac{Q}{V}}$

SQUARE ROOT KYUN? Yeh market impact ka empirical "square-root law" hai, jo bahut saare baad ke microstructure studies mein documented hai (jaise Almgren, Toth, Bouchaud). Note karo: Kyle ka original 1985 lambda model linear impact imply karta hai ($\Delta P=\lambda \cdot Q$); $\sqrt{Q/V}$ scaling ek empirical regularity hai jo real trade data mein observe ki gayi hai, Kyle's model ka direct consequence nahi. Intuitively, square root diminishing marginal impact capture karta hai—orders split karne wale informed traders unlimited profit extract nahi kar sakte.

Example: $\alpha =0.1$, $Q=1000$, $V=100,000$

• $s=0.1\times \sqrt{1000/100000}=0.1\times 0.1=0.01=100$ bps
• $50kestockpar:slippagecost=$1000 \times 50 \times 0.01 = $500$

Yeh step kyun? Square root diminishing returns capture karta hai—order size double karne se impact double nahi hoti. Volume se divide karna different liquidity regimes mein normalize karta hai.

3. Volatility-Adjusted Slippage

Assumption: High volatility → prices tezi se move hoti hain → zyada slippage.

Derivation:

• Latency $\tau$ (execution tak ka time) ke dauran, price volatility $\sigma$ ke saath random walk follow karta hai
• Expected price move: $\Delta P\sim \sigma \sqrt{\tau }$
• Worst-case (directional): $\Delta P=\sigma \sqrt{\tau }$ tumhare against

$\tau$ ke liye unit convention: Kyunki $\sigma$ annualized hai, $\tau$ ko ek year ke fraction ke roop mein express karna zaroori hai. Examples:

• Aadha trading day: $\tau =\frac{0.5}{252}\approx 0.00198\approx 0.002$ years
• Ek pura trading day: $\tau =\frac{1}{252}\approx 0.00397\approx 0.004$ years
• Kuch seconds ki latency: $\tau$ essentially is scale par $0$ hai, isliye intraday HFT models aksar per-second volatility use karte hain.

Example (half-day latency): $\sigma =0.30$ (30% annual), $\tau =0.5/252\approx 0.002$ years

• $s_{\text{vol}}=0.5\times 0.30\times \sqrt{0.002}=0.5\times 0.30\times 0.0447\approx 0.0067=67$ bps

Yeh step kyun? Hum $\sqrt{\tau }$ use karte hain kyunki price diffusion square root of time ke saath scale hoti hai (Brownian motion). Factor $k$ yeh acknowledge karta hai ki tumhe hamesha worst-case move nahi milta.

4. Combined Slippage Model

Real-world mein: Saare effects ek saath hote hain.

$s_{\text{total}}=s_{\text{fixed}}+\alpha \sqrt{\frac{Q}{V}}+k\sigma \sqrt{\tau }$

Example: Trade 500 shares, $V=50,000$, $\sigma =0.25$, $\tau =0.001$ years (~quarter trading day)

• Fixed: $s_{\text{fixed}}=0.0005=5$ bps
• Volume: $0.1\times \sqrt{500/50000}=0.1\times 0.1=0.01=100$ bps
• Volatility: $0.5\times 0.25\times \sqrt{0.001}=0.5\times 0.25\times 0.0316\approx 0.00395=39.5$ bps
• Total: $\approx 0.0145=144.5$ bps

Yeh step kyun? Dhyaan se note karo: volume term $0.01$ equals $1\%=100$ bps hai (kyunki $1\%=100$ bps, aur $0.01=100\times 0.0001$), 10 bps nahi. 500-share ka order jo daily volume ka 1% hai, already significant impact generate karta hai—yeh ek aur reminder hai bps conversions seedhe rakhne ka ($1\text{ bp}=0.0001$).

Backtest Mein Slippage Implement Karna

Step-by-step:

1. Apna model choose karo strategy frequency ke basis par:

   • High-frequency (seconds): volatility + volume model use karo
   • Medium-frequency (minutes-hours): volume + fixed use karo
   • Low-frequency (daily+): fixed slippage aksar kaafi hoti hai

2. Parameters calibrate karo real execution data se:

   • 100+ trades par actual fill prices vs. decision prices measure karo
   • $s$, $\alpha$, $k$ ko error minimize karne ke liye fit karo
   • Agar real data nahi hai: conservative estimates use karo (retail ke liye 10-20 bps, institutional ke liye 2-5 bps)

3. Har trade par apply karo:

   # Pseudocode for backtest engine
   def execute_order(decision_price, quantity, volume, volatility):
       s_fixed = 0.0005  # 5 bps  (recall: 1 bp = 0.0001)
       s_volume = 0.1 * sqrt(abs(quantity) / volume)
       s_volatility = 0.5 * volatility * sqrt(latency_in_years)
       total_slippage = s_fixed + s_volume + s_volatility
    
       if quantity > 0:  # Buy
           fill_price = decision_price * (1 + total_slippage)
       else:  # Sell
           fill_price = decision_price * (1 - total_slippage)
    
       return fill_price

Yeh structure kyun? Slippage directional hoti hai—hamesha tumhe hurt karti hai. Buys mein worse fills milte hain (higher price), sells mein worse fills milte hain (lower price).

Connections

• Transaction costs aur unka impact – slippage total transaction costs ka ek component hai
• Realistic order execution modeling – slippage ko partial fills aur fill probability ke saath extend karta hai
• Market microstructure basics – order book dynamics explain karta hai ki slippage kyun exist karti hai
• Look-ahead bias – slippage ignore karna look-ahead bias ka ek form hai (perfect execution assume karta hai)
• Position sizing – slippage costs position size ke saath scale hoti hain, optimal sizing ko affect karti hain

#flashcards/stock-market

Concept Map