Basic Strategies

This page presentes some european option trading strategies. All derivatives contracts are assumed to be on the same underlying asset, and having the same maturity date.

All the diagrams bellow take only into account the asset payoff at maturity as a function of the underlying asset value. They do not represent the profit/loss of holding a position on such assests as they ignore the options’ premium.

\(S_T\) is underlying asset value at maturity \(T\), and \(X\) is the option exercise price.

Synthetic forward

A synthetic forward (long position) can be created by buying a call and selling a put with the same exercise price.

A short position on a synthetic forward can be created by selling a call and buying a put with the same exercise price.

You can change the options’ exercise price (\(X\)) using the slider below.

viewof xsyn = Inputs.range([50, 150], {step: 1, label: "X (Exercise Price)", value:100})
viewof stsyn = Inputs.range([0, 150], {step: 1, label: "S_T", value:100})

longSyntheticForwardPayoff = Plot.plot({
  caption: "Synthetic Long Forward (Long Call + Short Put)",
  x: {
    domain: [0, 150],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([xsyn], {stroke: "gray", strokeDasharray: "4,4"}),
    // Long Call
    Plot.line([[0, 0], [xsyn, 0], [150, 150 - xsyn]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.5}),
    // Short Put
    Plot.line([[0, -(xsyn)], [xsyn, 0], [150, 0]], {stroke: "red", strokeWidth: 1.5, opacity: 0.5}),
    // Combined payoff (synthetic forward)
    Plot.line([[0, -xsyn], [150, 150 - xsyn]], {stroke: "green", strokeWidth: 2.5}),
    Plot.dot(
      [[stsyn, stsyn - xsyn]], 
      {
        fill: "green", 
        r: 5,
        title: d => `S_T: ${stsyn}
X: ${xsyn}
Payoff: ${stsyn - xsyn}`,
        tip: true
      })
  ],
  title: "Long Synthetic Forward (Long Call + Short Put)"
})

shortSyntheticForwardPayoff = Plot.plot({
  caption: "Synthetic Short Forward (Short Call + Long Put)",
  x: {
    domain: [0, 150],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([xsyn], {stroke: "gray", strokeDasharray: "4,4"}),
    // Short Call
    Plot.line([[0, 0], [xsyn, 0], [150, xsyn - 150]], {stroke: "red", strokeWidth: 1.5, opacity: 0.5}),
    // Long Put
    Plot.line([[0, xsyn], [xsyn, 0], [150, 0]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.5}),
    // Combined payoff (synthetic forward)
    Plot.line([[0, xsyn], [150, xsyn - 150]], {stroke: "purple", strokeWidth: 2.5}),
    Plot.dot(
      [[stsyn, xsyn - stsyn]], 
      {
        fill: "purple", 
        r: 5,
        title: d => `S_T: ${stsyn}
X: ${xsyn}
Payoff: ${xsyn - stsyn}`,
        tip: true
      })
  ],
  title: "Short Synthetic Forward (Short Call + Long Put)"
})

Notice that:

1. The long synthetic forward (long call + short put) has a payoff of \(S_T - X\), which is identical to a long position in a forward contract with forward price \(F_0 = X\).

2. The short synthetic forward (short call + long put) has a payoff of \(X - S_T\), which is identical to a short position in a forward contract with forward price \(F_0 = X\).

In both cases, the exercise price effectively becomes the forward price in these synthetic positions.

Spreads

A bull spread is the result of buying a call option with exercise price of \(X_1\) and selling a call option with exercise price \(X_2\),, where \(X_1 < X_2\).

A bear spread is the result of buying a put option with exercise price of \(X_2\) and selling a put option with exercise price \(X_1\), where \(X_1 < X_2\).
​

You can adjust the parameters below to see how they affect spread payoffs:

viewof x1 = Inputs.range([50, 120], {step: 1, label: "X₁ (Lower Exercise Price)", value:80})
viewof spreadSize = Inputs.range([5, 50], {step: 5, label: "Spread (X₂ - X₁)", value:20})
viewof stspread = Inputs.range([0, 150], {step: 1, label: "S_T", value:90})

// Calculate X₂ based on X₁ and the spread
x2 = x1 + spreadSize

bullSpreadPayoff = Plot.plot({
  caption: "Bull Spread (Long Call X₁ + Short Call X₂)",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-50, 50],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([x1], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([x2], {stroke: "gray", strokeDasharray: "4,4"}),
    // Long Call with X₁
    Plot.line([[0, 0], [x1, 0], [150, 150 - x1]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.5}),
    // Short Call with X₂
    Plot.line([[0, 0], [x2, 0], [150, x2 - 150]], {stroke: "red", strokeWidth: 1.5, opacity: 0.5}),
    // Combined payoff (bull spread)
    Plot.line([[0, 0], [x1, 0], [x2, x2 - x1], [150, x2 - x1]], {stroke: "green", strokeWidth: 2.5}),
    Plot.dot(
      [[stspread, Math.min(Math.max(0, stspread - x1), x2 - x1)]], 
      {
        fill: "green", 
        r: 5,
        title: d => `S_T: ${stspread}
X₁: ${x1}
X₂: ${x2}
Payoff: ${Math.min(Math.max(0, stspread - x1), x2 - x1)}`,
        tip: true
      })
  ],
  title: "Bull Spread (Long Call X₁ + Short Call X₂)"
})

bearSpreadPayoff = Plot.plot({
  caption: "Bear Spread (Long Put X₂ + Short Put X₁)",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-50, 50],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([x1], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([x2], {stroke: "gray", strokeDasharray: "4,4"}),
    // Long Put with X₂
    Plot.line([[0, x2], [x2, 0], [150, 0]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.5}),
    // Short Put with X₁
    Plot.line([[0, -x1], [x1, 0], [150, 0]], {stroke: "red", strokeWidth: 1.5, opacity: 0.5}),
    // Combined payoff (bear spread)
    Plot.line([[0, x2 - x1], [x1, x2 - x1], [x2, 0], [150, 0]], {stroke: "purple", strokeWidth: 2.5}),
    Plot.dot(
      [[stspread, Math.max(Math.min(x2 - stspread, x2 - x1), 0)]], 
      {
        fill: "purple", 
        r: 5,
        title: d => `S_T: ${stspread}
X₁: ${x1}
X₂: ${x2}
Payoff: ${Math.max(Math.min(x2 - stspread, x2 - x1), 0)}`,
        tip: true
      })
  ],
  title: "Bear Spread (Long Put X₂ + Short Put X₁)"
})

Key characteristics of spreads:

Bull Spread

• Created by buying a call with lower strike price \(X_1\) and selling a call with higher strike price \(X_2\)
• Maximum profit: \(X_2 - X_1\) (achieved when \(S_T \geq X_2\))
• Maximum loss: Premium paid for \(X_1\) call minus premium received for \(X_2\) call
• Bullish strategy: profits from moderate price increases in the underlying asset

Bear Spread

• Created by buying a put with higher strike price \(X_2\) and selling a put with lower strike price \(X_1\)
• Maximum profit: \(X_2 - X_1\) (achieved when \(S_T \leq X_1\))
• Maximum loss: Premium paid for \(X_2\) put minus premium received for \(X_1\) put
• Bearish strategy: profits from moderate price decreases in the underlying asset

Straddle

A long straddle is created by buying a call and a put with the same exercise price.

A bear straddle is created by selling a call and a put with the same exercise price.

You can adjust the parameters below to see how they affect spread payoffs:

viewof xstraddle = Inputs.range([50, 150], {step: 1, label: "X (Exercise Price)", value:100})
viewof ststraddle = Inputs.range([0, 200], {step: 1, label: "S_T", value:100})

longStraddlePayoff = Plot.plot({
  caption: "Long Straddle (Long Call + Long Put)",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([xstraddle], {stroke: "gray", strokeDasharray: "4,4"}),
    // Long Call
    Plot.line([[0, 0], [xstraddle, 0], [200, 200 - xstraddle]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.5}),
    // Long Put
    Plot.line([[0, xstraddle], [xstraddle, 0], [200, 0]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.5}),
    // Combined payoff (long straddle)
    Plot.line([[0, xstraddle], [xstraddle, 0], [200, 200 - xstraddle]], {stroke: "green", strokeWidth: 2.5}),
    Plot.dot(
      [[ststraddle, ststraddle <= xstraddle ? xstraddle - ststraddle : ststraddle - xstraddle]], 
      {
        fill: "green", 
        r: 5,
        title: d => `S_T: ${ststraddle}
X: ${xstraddle}
Payoff: ${ststraddle <= xstraddle ? xstraddle - ststraddle : ststraddle - xstraddle}`,
        tip: true
      })
  ],
  title: "Long Straddle (Long Call + Long Put)"
})

shortStraddlePayoff = Plot.plot({
  caption: "Short Straddle (Short Call + Short Put)",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([xstraddle], {stroke: "gray", strokeDasharray: "4,4"}),
    // Short Call
    Plot.line([[0, 0], [xstraddle, 0], [200, xstraddle - 200]], {stroke: "red", strokeWidth: 1.5, opacity: 0.5}),
    // Short Put
    Plot.line([[0, -xstraddle], [xstraddle, 0], [200, 0]], {stroke: "red", strokeWidth: 1.5, opacity: 0.5}),
    // Combined payoff (short straddle)
    Plot.line([[0, -xstraddle], [xstraddle, 0], [200, xstraddle - 200]], {stroke: "purple", strokeWidth: 2.5}),
    Plot.dot(
      [[ststraddle, ststraddle <= xstraddle ? ststraddle - xstraddle : xstraddle - ststraddle]], 
      {
        fill: "purple", 
        r: 5,
        title: d => `S_T: ${ststraddle}
X: ${xstraddle}
Payoff: ${ststraddle <= xstraddle ? ststraddle - xstraddle : xstraddle - ststraddle}`,
        tip: true
      })
  ],
  title: "Short Straddle (Short Call + Short Put)"
})

Key characteristics of straddles:

Long Straddle

• Created by buying both a call and a put with the same strike price \(X\)
• Profits when the underlying asset price moves significantly in either direction
• Maximum loss: Total premium paid for both options (occurs when \(S_T = X\))
• Unlimited payoff potential (theoretically) on the upside, and payoff potential up to \(X\) on the downside
• Used when expecting high volatility or a major price movement but uncertain about the direction

Short Straddle

• Created by selling both a call and a put with the same strike price \(X\)
• Profits when the underlying asset price remains stable near the strike price \(X\)
• Maximum profit: Total premium received from both options (occurs when \(S_T = X\))
• Unlimited payoff potential (theoretically) on the upside, and payoff potential up to \(X\) on the downside
• Used when expecting low volatility or minimal price movement

Strangle

A long straddle is the result of buying a call option with exercise price of \(X_2\) and buying a put option with exercise price \(X_1\), where \(X_1 < X_2\).

A short straddle is the result of selling a call option with exercise price of \(X_1\) and selling a put option with exercise price \(X_2\), where \(X_1 < X_2\).

You can adjust the parameters below to see how they affect spread payoffs:

viewof x1strangle = Inputs.range([50, 120], {step: 1, label: "X₁ (Lower Exercise Price)", value:80})
viewof strangleSize = Inputs.range([5, 50], {step: 5, label: "Spread (X₂ - X₁)", value:40})
viewof ststrangle = Inputs.range([0, 200], {step: 1, label: "S_T", value:100})

// Calculate X₂ based on X₁ and the spread
x2strangle = x1strangle + strangleSize

longStranglePayoff = Plot.plot({
  caption: "Long Strangle (Long Put X₁ + Long Call X₂)",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([x1strangle], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([x2strangle], {stroke: "gray", strokeDasharray: "4,4"}),
    // Long Put with X₁
    Plot.line([[0, x1strangle], [x1strangle, 0], [200, 0]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.5}),
    // Long Call with X₂
    Plot.line([[0, 0], [x2strangle, 0], [200, 200 - x2strangle]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.5}),
    // Combined payoff (long strangle)
    Plot.line([[0, x1strangle], [x1strangle, 0], [x2strangle, 0], [200, 200 - x2strangle]], {stroke: "green", strokeWidth: 2.5}),
    Plot.dot(
      [[ststrangle, ststrangle < x1strangle ? x1strangle - ststrangle : (ststrangle > x2strangle ? ststrangle - x2strangle : 0)]], 
      {
        fill: "green", 
        r: 5,
        title: d => `S_T: ${ststrangle}
X₁: ${x1strangle}
X₂: ${x2strangle}
Payoff: ${ststrangle < x1strangle ? x1strangle - ststrangle : (ststrangle > x2strangle ? ststrangle - x2strangle : 0)}`,
        tip: true
      })
  ],
  title: "Long Strangle (Long Put X₁ + Long Call X₂)"
})

shortStranglePayoff = Plot.plot({
  caption: "Short Strangle (Short Put X₁ + Short Call X₂)",
  x: {
    domain: [0, 200],
    label: "S_T"
  },
  y: {
    domain: [-150, 150],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([0]),
    Plot.ruleX([x1strangle], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([x2strangle], {stroke: "gray", strokeDasharray: "4,4"}),
    // Short Put with X₁
    Plot.line([[0, -x1strangle], [x1strangle, 0], [200, 0]], {stroke: "red", strokeWidth: 1.5, opacity: 0.5}),
    // Short Call with X₂
    Plot.line([[0, 0], [x2strangle, 0], [200, x2strangle - 200]], {stroke: "red", strokeWidth: 1.5, opacity: 0.5}),
    // Combined payoff (short strangle)
    Plot.line([[0, -x1strangle], [x1strangle, 0], [x2strangle, 0], [200, x2strangle - 200]], {stroke: "purple", strokeWidth: 2.5}),
    Plot.dot(
      [[ststrangle, ststrangle < x1strangle ? ststrangle - x1strangle : (ststrangle > x2strangle ? x2strangle - ststrangle : 0)]], 
      {
        fill: "purple", 
        r: 5,
        title: d => `S_T: ${ststrangle}
X₁: ${x1strangle}
X₂: ${x2strangle}
Payoff: ${ststrangle < x1strangle ? ststrangle - x1strangle : (ststrangle > x2strangle ? x2strangle - ststrangle : 0)}`,
        tip: true
      })
  ],
  title: "Short Strangle (Short Put X₁ + Short Call X₂)"
})

Key characteristics of strangles:

Long Strangle

• Created by buying a put with lower strike price \(X_1\) and a call with higher strike price \(X_2\)
• Profits when the underlying asset price moves significantly in either direction (beyond either strike price)
• Maximum loss: Total premium paid for both options (occurs when \(S_T\) is between \(X_1\) and \(X_2\))
• Unlimited payoff potential on the upside, and payoff potential up to \(X_1\) on the downside
• Typically cheaper to establish than a straddle, but requires a larger price movement to be profitable

Short Strangle

• Created by selling a put with lower strike price \(X_1\) and a call with higher strike price \(X_2\)
• Profits when the underlying asset price remains between the two strike prices
• Maximum profit: Total premium received from both options (occurs when \(S_T\) is between \(X_1\) and \(X_2\))
• Unlimited potential payoff if \(S_T > X_2\), and payoff potential of \(-X_1\) if \(S_T < X_1\)
• Provides a wider profit zone than a short straddle but with similar unlimited negative payoffs characteristics

Butterfly spread

A long buttefly spread is created by selling two call options with exercise price \(X_2\), and buying a call option with an exercise price of \(X_1\), and buying a call option with an exercise price of \(X_3\). Where \(X_1 < X_2 < X_3\), and the difference between the exercise prices are the same \((X_2 - X_1 = X_3 - X_2)\).

A short buttefly spread is created by buying two call options with exercise price \(X_2\), and selling a call option with an exercise price of \(X_1\), and selling a call option with an exercise price of \(X_3\). Where \(X_1 < X_2 < X_3\), and the difference between the exercise prices are the same \((X_2 - X_1 = X_3 - X_2)\).

You can adjust the parameters below to see how they affect butterfly spread payoffs:

viewof x2butterfly = Inputs.range([70, 130], {step: 5, label: "X₂ (Middle Exercise Price)", value:100})
viewof wingSize = Inputs.range([5, 30], {step: 5, label: "Wing Size (X₂-X₁)", value:20})
viewof stbutterfly = Inputs.range([50, 150], {step: 1, label: "S_T", value:100})

// Calculate X₁ and X₃ based on X₂ and wing size
x1butterfly = x2butterfly - wingSize
x3butterfly = x2butterfly + wingSize

longButterflyPayoff = Plot.plot({
  caption: "Long Butterfly (Long Call X₁ + Short 2 Calls X₂ + Long Call X₃)",
  x: {
    domain: [Math.max(0, x1butterfly - 20), x3butterfly + 20],
    label: "S_T"
  },
  y: {
    domain: [-wingSize - 5, wingSize + 5],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([x1butterfly], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([x2butterfly], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([x3butterfly], {stroke: "gray", strokeDasharray: "4,4"}),
    // Long Call with X₁
    Plot.line([[0, 0], [x1butterfly, 0], [x3butterfly, x3butterfly - x1butterfly], [200, 200 - x1butterfly]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.3}),
    // Short 2 Calls with X₂
    Plot.line([[0, 0], [x2butterfly, 0], [x3butterfly, 2 * (x2butterfly - x3butterfly)], [200, 2 * (x2butterfly - 200)]], {stroke: "red", strokeWidth: 1.5, opacity: 0.3}),
    // Long Call with X₃
    Plot.line([[0, 0], [x3butterfly, 0], [200, 200 - x3butterfly]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.3}),
    // Combined payoff (long butterfly)
    Plot.line([
      [0, 0], 
      [x1butterfly, 0], 
      [x2butterfly, wingSize], 
      [x3butterfly, 0], 
      [200, 0]
    ], {stroke: "green", strokeWidth: 2.5}),
    Plot.dot(
      [[stbutterfly, calculateButterflyPayoff(stbutterfly, x1butterfly, x2butterfly, x3butterfly)]], 
      {
        fill: "green", 
        r: 5,
        title: d => `S_T: ${stbutterfly}
X₁: ${x1butterfly}
X₂: ${x2butterfly}
X₃: ${x3butterfly}
Payoff: ${calculateButterflyPayoff(stbutterfly, x1butterfly, x2butterfly, x3butterfly)}`,
        tip: true
      })
  ],
  title: "Long Butterfly Spread"
})

function calculateButterflyPayoff(st, x1, x2, x3) {
  // Long Call X₁
  const call1 = Math.max(0, st - x1);
  // Short 2 Calls X₂
  const call2 = 2 * Math.max(0, st - x2);
  // Long Call X₃
  const call3 = Math.max(0, st - x3);
  
  return call1 - call2 + call3;
}

shortButterflyPayoff = Plot.plot({
  caption: "Short Butterfly (Short Call X₁ + Long 2 Calls X₂ + Short Call X₃)",
  x: {
    domain: [Math.max(0, x1butterfly - 20), x3butterfly + 20],
    label: "S_T"
  },
  y: {
    domain: [-wingSize - 5, wingSize + 5],
    label: "Payoff"
  },
  grid: true,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([x1butterfly], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([x2butterfly], {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([x3butterfly], {stroke: "gray", strokeDasharray: "4,4"}),
    // Short Call with X₁
    Plot.line([[0, 0], [x1butterfly, 0], [x3butterfly, x1butterfly - x3butterfly], [200, x1butterfly - 200]], {stroke: "red", strokeWidth: 1.5, opacity: 0.3}),
    // Long 2 Calls with X₂
    Plot.line([[0, 0], [x2butterfly, 0], [x3butterfly, 2 * (x3butterfly - x2butterfly)], [200, 2 * (200 - x2butterfly)]], {stroke: "blue", strokeWidth: 1.5, opacity: 0.3}),
    // Short Call with X₃
    Plot.line([[0, 0], [x3butterfly, 0], [200, x3butterfly - 200]], {stroke: "red", strokeWidth: 1.5, opacity: 0.3}),
    // Combined payoff (short butterfly)
    Plot.line([
      [0, 0], 
      [x1butterfly, 0], 
      [x2butterfly, -wingSize], 
      [x3butterfly, 0], 
      [200, 0]
    ], {stroke: "purple", strokeWidth: 2.5}),
    Plot.dot(
      [[stbutterfly, -calculateButterflyPayoff(stbutterfly, x1butterfly, x2butterfly, x3butterfly)]], 
      {
        fill: "purple", 
        r: 5,
        title: d => `S_T: ${stbutterfly}
X₁: ${x1butterfly}
X₂: ${x2butterfly}
X₃: ${x3butterfly}
Payoff: ${-calculateButterflyPayoff(stbutterfly, x1butterfly, x2butterfly, x3butterfly)}`,
        tip: true
      })
  ],
  title: "Short Butterfly Spread"
})

Key characteristics of butterfly spreads:

Long Butterfly Spread

• Created by combining: long call at lower strike \(X_1\) + short two calls at middle strike \(X_2\) + long call at higher strike \(X_3\)
• Maximum payoff: \(X_2 - X_1\) (equal to the wing size, achieved when \(S_T = X_2\))
• Maximum loss: Net premium paid (occurs when \(S_T \leq X_1\) or \(S_T \geq X_3\))
• Market view: Expecting low volatility with the price staying near the middle strike \(X_2\)

Short Butterfly Spread

• Created by combining: short call at lower strike \(X_1\) + long two calls at middle strike \(X_2\) + short call at higher strike \(X_3\)
• Maximum profit: Net premium received (occurs when \(S_T \leq X_1\) or \(S_T \geq X_3\))
• Minimum payoff: \(X_2 - X_1\) (equal to the wing size, incurred when \(S_T = X_2\))
• Market view: Expecting high volatility with the price moving away from middle strike \(X_2\)