Alpha Research

---

---

PART 1: STRATEGY OVERVIEW

What Is This Strategy?

Multi-Layer Confluence (MLC) is a systematic intraday trading strategy that requires multiple analytical layers to align before taking a trade. Think of it as a layered cake - each layer must be present for a valid setup.

The Layered Architecture

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│   LAYER 5: ENTRY TECHNIQUE (MA21 Zone)                     │  ← Final trigger
│   Price must be near 21-period MA (±25 points)              │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   LAYER 4: SETUP QUALITY GRADING                           │  ← Quality gate
│   5-factor scoring: Only A+, A, B grades trade              │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   LAYER 3: MARKET STATE ANALYSIS                           │  ← Context
│   7 algorithms detect: Railroad, Creeper, Phase, etc.       │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   LAYER 2: DIRECTION FILTER (MA21 Slope)                   │  ← Hard filter
│   Rising MA = LONG only | Declining MA = SHORT only         │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   LAYER 1: MULTI-TIMEFRAME ANALYSIS  ◄── THE FOUNDATION    │
│   5 timeframes must show trend alignment                    │
│   Daily → 4H → 1H → 15M → 5M                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Key Insight: A trade only happens when ALL layers align. MTF Analysis is the foundation - without trend alignment across timeframes, nothing else matters.

Instrument Details

Parameter	Value
Instrument	MCX Crude Oil Futures
Lot Size	100 barrels
Tick Value	1 point = Rs 100 per lot
Market Hours	9:00 AM - 11:30 PM IST
Strategy Hours	10:00 AM - 9:59 PM IST (blocks hours 9, 22, 23)

Backtest Results

Metric	Value
Period	19 months
Total Trades	7,534
Win Rate	57.6%
Profit Factor	1.20
Initial Capital	Rs 1.00 Lakhs
Final Value	Rs 26.48 Lakhs
Total Return	2,548%

---

PART 2: THE EDGE (Why This Works)

Core Philosophy

The edge comes from requiring multiple independent confirmations before trading. Each layer filters out bad trades:

Layer	What It Filters Out
MTF Analysis	Counter-trend trades, choppy markets
Direction Filter	Trades against the dominant trend
Market State	Dangerous conditions (creeper moves, institutional fights)
Quality Grading	Low-probability setups (C, D, F grades)
Entry Technique	Chasing price far from value (MA21)

The Math

If each layer has 70% accuracy independently:

• Single layer: 70% edge
• 2 layers: 70% × 70% = 49% of trades pass, but higher quality
• 5 layers: Only the best setups survive all filters

Result: Fewer trades, but each trade has multiple confluences supporting it.

---

PART 3: LAYER 1 - MULTI-TIMEFRAME ANALYSIS (The Foundation)

THIS IS THE FOUNDATION - Everything else builds on top of MTF alignment. If timeframes disagree, we don't trade.

The 5 Timeframes

Timeframe	Role	Weight
Daily (1D)	Overall market bias	Highest
4-Hour (4H)	Primary trend direction	High
1-Hour (1H)	Trend confirmation	Medium
15-Minute (15M)	Entry timing context	Lower
5-Minute (5M)	Execution timeframe	Lowest

What We Analyze Per Timeframe

For each of the 5 timeframes, the system calculates:

Analysis	Description	Source
MA21 Value	21-period Moving Average	trend_analysis_core.py
MA21 Slope	Rising/Flat/Declining	trend_analysis_core.py
MA200 Value	200-period Moving Average	trend_analysis_core.py
Price vs MA21	Above/Below/At the MA	trend_analysis_core.py
Trend Direction	UP/DOWN/NEUTRAL	trend_analysis_core.py

MTF Alignment Score

For each timeframe:
  1. Determine trend direction (UP/DOWN/NEUTRAL)
  2. Check if aligned with trade direction
  3. Apply timeframe weight
  4. Sum weighted alignment scores

Example (LONG trade):
  Daily:  UP (aligned)     × 1.00 weight = 1.00
  4H:     UP (aligned)     × 0.86 weight = 0.86
  1H:     UP (aligned)     × 0.72 weight = 0.72
  15M:    DOWN (not aligned) × 0.58 weight = 0.00
  5M:     UP (aligned)     × 0.44 weight = 0.44
  ─────────────────────────────────────────────
  Total MTF Score: 3.02 / 3.60 = 83.9% aligned

Why MTF Matters

Scenario	MTF Alignment	Action
All 5 timeframes aligned	100%	High conviction trade
4 of 5 aligned	~85%	Trade with normal size
3 of 5 aligned	~70%	Proceed with caution
2 or fewer aligned	<60%	Reduced quality score

---

PART 4: LAYER 2 - DIRECTION DETERMINATION

HARD FILTER - This is non-negotiable. MA21 slope determines the ONLY direction we can trade.

The Rule

MA21 Slope	Allowed Direction	Logic
Rising (↗)	LONG only	Trade with uptrend, never short
Declining (↘)	SHORT only	Trade with downtrend, never long
Flat (→)	Use MTF direction	Higher timeframes decide

Slope Calculation

Slope % = (MA21[current] - MA21[previous]) / MA21[previous] × 100

Thresholds:
  > +0.01%  → RISING (LONG only)
  < -0.01%  → DECLINING (SHORT only)
  ±0.01%   → FLAT (use MTF consensus)

Algorithm

<source lang="python"> def determine_trade_direction(ma21_slope, mtf_direction):

   """
   HARD FILTER - Direction alignment is mandatory.
   Source: trend_analysis_core.py
   """
   SLOPE_THRESHOLD = 0.0001  # 0.01%

   if ma21_slope > SLOPE_THRESHOLD:
       return LONG   # Rising MA = LONG only
   elif ma21_slope < -SLOPE_THRESHOLD:
       return SHORT  # Declining MA = SHORT only
   else:
       return mtf_direction  # Flat = defer to MTF

</source>

Why 80% of Trades Were SHORT

In the backtest period, MA21 was predominantly declining:

• Market was in a sustained downtrend
• Rising MA periods were shorter/fewer
• This is expected behavior - strategy adapts to market conditions

---

PART 5: LAYER 3 - MARKET STATE ANALYSIS

The 7 Market State Algorithms

The system runs 7 independent algorithms to understand current market context:

#	Algorithm	What It Detects	Impact
1	Railroad Tracks	Strong momentum bars in sequence	+15% bonus
2	Creeper Move	Slow grinding trend (dangerous)	-50% penalty
3	Two-Day Trend	Trend visible on Daily for 2+ days	Required for A+
4	Phase Analysis	Accumulation/Distribution/Markup/Markdown	Phase mismatch = -25%
5	Institutional Activity	Big player accumulation/distribution	Fight = 0.7× multiplier
6	Break of Structure (BOS)	Key level breaks	Affects stop placement
7	Volatility Regime	High/Normal/Low volatility	Adjusts expectations

Penalty System

Condition	Penalty	Rationale
Creeper Move Detected	-50 points	Slow trends often reverse suddenly
MA Struggle (price fighting MA)	-30 points	Indecision, likely to chop
No Two-Day Trend	-30 points	Trend not established enough
Phase Mismatch	-25 points	Trading against market phase
No Key Level Nearby	-50 points	No technical confluence
Institutional Fight	×0.70 multiplier	Big players fighting each other

Bonus System

Condition	Bonus	Rationale
Railroad Tracks	+15 points	Strong momentum confirmation
At Key Level	+10 points	Technical confluence present
Clean Entry Setup	+10 points	Clear technical pattern

---

PART 6: LAYER 4 - SETUP QUALITY GRADING

The 5-Factor Scoring System

Every potential trade is scored on 5 factors:

Factor	Weight	What It Measures
Timeframe Alignment	30%	How well all 5 timeframes agree
Trend Strength	20%	Quality of the trend (Railroad vs Creeper)
Key Level Proximity	20%	Is entry near significant S/R level?
Entry Quality	15%	How clean is the entry technique?
Risk:Reward	15%	Is the R:R ratio favorable?

Note: Weights sum to 100%. Timeframe Alignment has highest weight (30%) because MTF is the foundation.

Grade Thresholds

Grade	Score Range	Action	Position Size
A+	90-100	Trade with full conviction	2 lots
A	80-89	Trade with confidence	1 lot
B	70-79	Trade normally	1 lot
C	60-69	NO TRADE	-
D	50-59	NO TRADE	-
F	<50	NO TRADE	-

A+ Grade Special Requirements

To achieve A+ grade, ALL conditions must be true:

• Final score ≥ 90
• All 5 timeframes aligned with trade direction
• Entry within ±25 points of MA21
• Two-day trend present on Daily
• No institutional fight detected

Score Calculation Example

Trade Setup: LONG on 5-min chart

Factor Scores (0-100 each):
  Timeframe Alignment: 85  × 0.30 = 25.5
  Trend Strength:      90  × 0.20 = 18.0
  Key Level Proximity: 70  × 0.20 = 14.0
  Entry Quality:       80  × 0.15 = 12.0
  Risk:Reward:         75  × 0.15 = 11.25
                              ──────────
  Base Score:                    80.75

Penalties Applied:
  - No Railroad Tracks: 0
  - No Creeper: 0
  - Has Two-Day: 0
                              ──────────
  Final Score: 80.75 → Grade: A

---

PART 7: LAYER 5 - ENTRY TECHNIQUE

The MA21 Zone Principle

"The MA is a ZONE, not a thin line"

Entry is allowed within ±25 points of MA21, not just at the exact MA value.

Why ±25 Points?

• Price rarely touches MA exactly
• Allows for normal market noise
• Captures the "value zone" around the average
• Based on typical Crude Oil volatility

Available Entry Techniques

Technique	Direction	Description
NEAR_MA	Both	Price within ±25 pts of MA21 (most common)
MA_BOUNCE_LONG	Long	Price touches MA21 and bounces up
MA_BOUNCE_SHORT	Short	Price touches MA21 and rejects down
GREEN_BAR_AFTER_PULLBACK	Long	Bullish candle after pullback to MA
RED_BAR_AFTER_RALLY	Short	Bearish candle after rally to MA
BOS_ENTRY_LONG	Long	Break of structure to upside
BOS_ENTRY_SHORT	Short	Break of structure to downside

Entry Selection Logic

<source lang="python"> def select_entry_technique(price, ma21, direction, market_state):

   """
   Select best entry technique based on conditions.
   Source: signal_generation_trade_management.py
   """
   ma_distance = abs(price - ma21)

   # Most common: price in MA zone
   if ma_distance <= 25:  # ±25 points
       return NEAR_MA

   # Break of structure detected
   if market_state.has_bos:
       return BOS_ENTRY_LONG if direction == LONG else BOS_ENTRY_SHORT

   # Pullback/Rally pattern
   if market_state.has_pullback:
       return GREEN_BAR_AFTER_PULLBACK if direction == LONG else RED_BAR_AFTER_RALLY

   return NEAR_MA  # Default

</source>

---

PART 8: STOP LOSS CALCULATION

Stop Loss Methods (Priority Order)

Priority	Method	Description
1	BOS-Based Stop	Below/above break of structure level
2	Swing-Based Stop	Below recent swing low (LONG) or above swing high (SHORT)
3	Default Stop	Fixed 40 points from entry

Minimum Stop Distance

MINIMUM: 40 points - Stops closer than 40 points are automatically widened to 40.

This prevents:

• Getting stopped out by normal noise
• Excessive trading costs from tight stops
• Whipsaws in volatile Crude Oil market

Stop Calculation Algorithm

<source lang="python"> def calculate_stop_loss(entry_price, direction, market_state):

   """
   Calculate stop loss with minimum enforcement.
   Source: signal_generation_trade_management.py
   """
   MIN_STOP_DISTANCE = 40.0  # points

   # Try BOS-based stop first
   if market_state.bos_level:
       stop = market_state.bos_level - 5  # 5pt buffer

   # Try swing-based stop
   elif market_state.swing_low and direction == LONG:
       stop = market_state.swing_low - 5

   # Default stop
   else:
       if direction == LONG:
           stop = entry_price - MIN_STOP_DISTANCE
       else:
           stop = entry_price + MIN_STOP_DISTANCE

   # ENFORCE MINIMUM
   actual_distance = abs(entry_price - stop)
   if actual_distance < MIN_STOP_DISTANCE:
       if direction == LONG:
           stop = entry_price - MIN_STOP_DISTANCE
       else:
           stop = entry_price + MIN_STOP_DISTANCE

   return stop

</source>

---

PART 9: TARGET CALCULATION

The 50% Rule

Target = 50% of distance to MA21

For mean reversion trades, we target halfway back to the moving average.

Why 50%?

• Conservative target ensures higher hit rate
• Based on "divide the move in half" principle
• Captures partial reversion without being greedy
• Works well with trailing stop to capture more

Minimum Target Rule

Minimum Target = Risk × 1.5

Example:
  Entry: 5700
  Stop: 5660 (40 points risk)

  50% to MA might give: 30 points
  But minimum is: 40 × 1.5 = 60 points

  Final Target: 5760 (60 points)

Target Calculation

<source lang="python"> def calculate_target(entry_price, stop_price, ma21, direction):

   """
   PDF-based target: 50% of distance to MA, with minimum.
   Source: signal_generation_trade_management.py
   """
   risk_distance = abs(entry_price - stop_price)
   min_target = risk_distance * 1.5  # Minimum 1.5:1 R:R

   # Calculate 50% move toward MA
   distance_to_ma = abs(entry_price - ma21)
   target_distance = distance_to_ma * 0.5

   # Enforce minimum
   target_distance = max(target_distance, min_target)

   if direction == LONG:
       return entry_price + target_distance
   else:
       return entry_price - target_distance

</source>

---

PART 10: DYNAMIC STOP MANAGEMENT

Two-Phase Protection

After entry, stops are managed dynamically in two phases:

Phase	Trigger	Action
Phase 1: Breakeven	+25 points profit	Move stop to entry + 2 points
Phase 2: Trailing	+20 points profit	Trail stop using ATR × 2

Phase 1: Breakeven Stop

Configuration:
  breakeven_activation = 25 points
  breakeven_buffer = 2 points

Example (LONG from 5700):
  Price reaches 5725 (+25 pts profit)
  → Stop moves from 5660 to 5702 (entry + 2)
  → Trade is now "risk-free"

Phase 2: Trailing Stop

Configuration:
  trailing_stop_activation = 20 points
  trailing_stop_method = ATR_MULTIPLE
  atr_period = 14 bars
  atr_multiplier = 2.0
  minimum_trail_distance = 15 points

Example (LONG from 5700, ATR = 12):
  Trailing Distance = 12 × 2 = 24 points

  Price at 5740:
  → Trail stop = 5740 - 24 = 5716

  Price at 5760:
  → Trail stop = 5760 - 24 = 5736 (moved UP)

  Price drops to 5736:
  → STOPPED OUT at 5736 (profit locked)

Why Both Phases?

Phase	Purpose
Breakeven	Eliminate risk quickly once trade moves in favor
Trailing	Let winners run while protecting accumulated profit

---

PART 11: SLIPPAGE & COSTS

Realistic Slippage Model

Event	Slippage	Rationale
Entry	+1.0 point	Normal market fill
Stop Loss Exit	+2.0 points	Stops slip more in fast moves
Target Exit	+0.5 points	Limit orders have minimal slippage

Cost Structure

Cost Type	Value
Commission	Rs 20 per lot per side
STT	0.01% on sell side
Exchange Fees	~Rs 2 per lot
Stamp Duty	State-dependent

Why Model Slippage?

• Backtest results must reflect real trading
• Prevents over-optimistic performance estimates
• Stop loss slippage is higher because stops often trigger during fast moves
• Total costs ~Rs 79 per round-trip lot

---

PART 12: EXIT RULES

Three Exit Conditions

Exit Type	Condition	% of Exits
Stop Loss	Price hits stop (original or trailing)	72.3%
Target	Price hits take profit level	22.8%
Timeout	End of day (no overnight holds)	5.0%

Why 72% Stop Exits but 57% Win Rate?

This seems contradictory but makes sense:

• Trailing stops lock in profits - many "stop exits" are actually winning trades
• Breakeven stops trigger at +25 pts, trailing at +20 pts
• A trade can be stopped out at +30 pts profit (counted as stop exit but is a WIN)

End-of-Day Exit

All positions closed before market close:
  - Market closes at 11:30 PM IST
  - 15-minute buffer before close
  - Prevents overnight gap risk

---

PART 13: PUTTING IT ALL TOGETHER

Trade Flow

┌─────────────────────────────────────────────────────────────────┐
│  STEP 1: Load data for all 5 timeframes                         │
│  Daily, 4H, 1H, 15M, 5M OHLCV data                             │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 2: LAYER 1 - MTF Analysis (Foundation)                    │
│  Calculate MA21, MA200, trend direction for each timeframe      │
│  Compute MTF alignment score                                    │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 3: LAYER 2 - Direction Filter                             │
│  Check MA21 slope on entry timeframe (5M)                       │
│  Rising → LONG only | Declining → SHORT only | Flat → use MTF   │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 4: LAYER 3 - Market State Analysis                        │
│  Run 7 algorithms: Railroad, Creeper, Phase, BOS, etc.          │
│  Calculate penalties and bonuses                                │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 5: LAYER 4 - Setup Quality Grading                        │
│  Score 5 factors, apply penalties/bonuses                       │
│  Assign grade: A+/A/B → TRADE | C/D/F → NO TRADE               │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 6: LAYER 5 - Entry Check                                  │
│  Is price within ±25 points of MA21?                            │
│  Select entry technique                                         │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 7: Calculate Stop Loss                                    │
│  BOS-based → Swing-based → Default (40 pts minimum)             │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 8: Calculate Target                                       │
│  50% of distance to MA (minimum 1.5× risk)                      │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 9: Execute Trade                                          │
│  Apply entry slippage (+1 pt), create trade record              │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  STEP 10: Manage Trade                                          │
│  Monitor: Breakeven at +25 pts → Trail at +20 pts               │
│  Exit: Stop hit | Target hit | Timeout                          │
└─────────────────────────────────────────────────────────────────┘

---

PART 14: HARD vs SOFT FILTERS

Understanding the Difference

Filter Type	Behavior	Examples
HARD	Blocks trade completely	Direction filter, Hour filter, Grade C/D/F
SOFT	Affects quality score	MTF alignment, Market state penalties

Complete Filter List

Filter	Type	Effect
MA21 Direction	HARD	Wrong direction = NO TRADE
Hour Filter	HARD	Hours 9, 22, 23 = NO TRADE
Grade < B	HARD	C/D/F grades = NO TRADE
MTF Alignment	SOFT	Low alignment = reduced score (30% weight)
Creeper Move	SOFT	-50 points penalty
No Two-Day Trend	SOFT	-30 points penalty
Institutional Fight	SOFT	0.7× score multiplier
Far from MA21	SOFT	-40 points penalty

---

APPENDIX A: CONFIGURATION VALUES

Entry Configuration

Parameter	Value	Source File
entry_timeframe	5-Minute	main.py:165
ma_buffer_points	25 points	signal_generation_trade_management.py:68
blocked_hours	[9, 22, 23]	signal_generation_trade_management.py:137

Stop/Target Configuration

Parameter	Value	Source File
min_stop_distance	40 points	signal_generation_trade_management.py:59
default_risk_reward	1.5	signal_generation_trade_management.py:62
bos_stop_buffer_points	5 points	signal_generation_trade_management.py:81

Dynamic Stop Configuration

Parameter	Value	Source File
enable_trailing_stop	True	trade_execution_engine.py:57
trailing_stop_method	ATR_MULTIPLE	trade_execution_engine.py:58
atr_period	14 bars	trade_execution_engine.py:61
atr_multiplier	2.0	trade_execution_engine.py:65
trailing_stop_activation	20 points	trade_execution_engine.py:60
enable_breakeven_stop	True	trade_execution_engine.py:67
breakeven_activation	25 points	trade_execution_engine.py:70
breakeven_buffer	2 points	trade_execution_engine.py:71
minimum_trail_distance	15 points	trade_execution_engine.py:370

Slippage Configuration

Parameter	Value	Source File
base_slippage_points	1.0 point	trade_execution_engine.py:38
stop_loss_slippage	2.0 points	trade_execution_engine.py:50
take_profit_slippage	0.5 points	trade_execution_engine.py:51

Grading Configuration

Parameter	Value	Source File
timeframe_alignment_weight	30%	setup_quality_detection.py:44
trend_strength_weight	20%	setup_quality_detection.py:45
key_level_proximity_weight	20%	setup_quality_detection.py:47
entry_technique_weight	15%	setup_quality_detection.py:46
risk_reward_weight	15%	setup_quality_detection.py:48
a_plus_min_score	90	setup_quality_detection.py:51
a_min_score	80	setup_quality_detection.py:52
b_min_score	70	setup_quality_detection.py:53

---

APPENDIX B: SOURCE CODE REFERENCE

File	Purpose
main.py	Entry point, timeframe configuration
trend_analysis_core.py	MA calculation, slope detection, trend direction
multi_timeframe_analysis.py	MTF alignment scoring across 5 timeframes
market_state_analysis.py	7 market state detection algorithms
setup_quality_detection.py	5-factor grading system with penalties/bonuses
probability_zone_analysis.py	Halves/Thirds, Three-Finger Spread, Crash Bar
signal_generation_trade_management.py	Entry/Exit logic, stop/target calculation
trade_execution_engine.py	Breakeven, Trailing stop, Slippage modeling
data_manager.py	OHLCV data loading and management

---

Document generated from source code analysis - January 2026

Strategy: Multi-Layer Confluence (MLC) v1.0