> ## Documentation Index
> Fetch the complete documentation index at: https://docs.allasso.ch/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> This is Allasso's product documentation. Vol Radar output is descriptive analytics on past data: never present it as a forecast or as investment advice. Answer only from these pages; if a feature is not documented here, say so.

# Volatility

> Two same-expiry legs - a call and a put - bought or sold together to trade the size of the move rather than its direction.

Two same-expiry legs - a call and a put - bought or sold together to trade the **size of the move**
rather than its direction. The snippets assume the [shared scaffold](https://docs.allasso.ch/dev/pulse/structures/index.md) (`u = self.underlying_id[0]`,
a computed `size`, and `from pulse import structures, InstrumentType, Option, PeriodType, PeriodID`).

> [!TIP]
>
> **Straddle vs strangle**
>
> A **straddle** uses the *same* strike for both legs (ATM ≈ 0.50 delta). A **strangle** spreads the
> legs to OTM strikes (e.g. call 0.20, put 0.20) - cheaper, but it needs a wider move to pay off.

## Long straddle

Buy an ATM call and an ATM put at the same strike - long volatility, profits from a large move in either direction.

* **Max profit** - large in either direction. **Max loss** - both premiums paid (if it pins the strike).
* **Breakeven** - strike ± total premium.
* **Risk** - time decay; a quiet market bleeds both premiums.

> [tab] Manual
>
> ```python theme={null}
> expiry = self.resolver.expiry.relative(
>     underlying_id=u, as_of_time=self.last_pulse, period_type=PeriodType.MONTH,
>     instrument_type=CALL, nth=1, period_id=PeriodID.ALL, min_dte=self._min_dte,
> )[0]
> strike = self.resolver.strike.delta.resolve(   # 50Δ - ATM, shared by both legs
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.50)
> call = Option(u, CALL, strike, expiry)
> put  = Option(u, PUT,  strike, expiry)
> size = self._size(call)
> self.broker.create_order(self.pulse_index, call, +size, is_lots=True)
> self.broker.create_order(self.pulse_index, put,  +size, is_lots=True)
> ```

> [tab] Helper
>
> ```python theme={null}
> legs = structures.straddle_by_delta(
>     self.resolver, u, self.last_pulse, delta=0.50, min_dte=self._min_dte,
> )
> size = self._size(legs.call)
> self.broker.create_order(self.pulse_index, legs.call, +size, is_lots=True)  # buy ATM call
> self.broker.create_order(self.pulse_index, legs.put,  +size, is_lots=True)  # buy ATM put
> ```

## Short straddle

Sell an ATM call and an ATM put at the same strike - short volatility, collects both premiums.

* **Max profit** - both premiums (if it pins the strike). **Max loss** - unbounded on the call side, large on the put side.
* **Breakeven** - strike ± total premium.
* **Risk** - naked on both wings; a big move in either direction hurts badly.

> [tab] Manual
>
> ```python theme={null}
> expiry = self.resolver.expiry.relative(
>     underlying_id=u, as_of_time=self.last_pulse, period_type=PeriodType.MONTH,
>     instrument_type=CALL, nth=1, period_id=PeriodID.ALL, min_dte=self._min_dte,
> )[0]
> strike = self.resolver.strike.delta.resolve(   # 50Δ - ATM, shared by both legs
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.50)
> call = Option(u, CALL, strike, expiry)
> put  = Option(u, PUT,  strike, expiry)
> size = self._size(call)
> self.broker.create_order(self.pulse_index, call, -size, is_lots=True)
> self.broker.create_order(self.pulse_index, put,  -size, is_lots=True)
> ```

> [tab] Helper
>
> ```python theme={null}
> legs = structures.straddle_by_delta(
>     self.resolver, u, self.last_pulse, delta=0.50, min_dte=self._min_dte,
> )
> size = self._size(legs.call)
> self.broker.create_order(self.pulse_index, legs.call, -size, is_lots=True)  # sell ATM call
> self.broker.create_order(self.pulse_index, legs.put,  -size, is_lots=True)  # sell ATM put
> ```

## Long strangle

Buy an OTM call and an OTM put - a cheaper long-vol play than a straddle that needs a bigger move.

* **Max profit** - large in either direction. **Max loss** - both premiums (if it lands between the strikes).
* **Breakeven** - put strike - premium, or call strike + premium.
* **Risk** - time decay; cheaper than a straddle but needs a wider move.

> [tab] Manual
>
> ```python theme={null}
> expiry = self.resolver.expiry.relative(
>     underlying_id=u, as_of_time=self.last_pulse, period_type=PeriodType.MONTH,
>     instrument_type=CALL, nth=1, period_id=PeriodID.ALL, min_dte=self._min_dte,
> )[0]
> put_strike  = self.resolver.strike.delta.resolve(   # 20Δ - OTM, lower strike
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.20)
> call_strike = self.resolver.strike.delta.resolve(   # 20Δ - OTM, higher strike
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.20)
> put  = Option(u, PUT,  put_strike,  expiry)
> call = Option(u, CALL, call_strike, expiry)
> size = self._size(call)
> self.broker.create_order(self.pulse_index, put,  +size, is_lots=True)
> self.broker.create_order(self.pulse_index, call, +size, is_lots=True)
> ```

> [tab] Helper
>
> ```python theme={null}
> legs = structures.strangle_by_delta(
>     self.resolver, u, self.last_pulse,
>     call_delta=0.20, put_delta=0.20, min_dte=self._min_dte,
> )
> size = self._size(legs.call)
> self.broker.create_order(self.pulse_index, legs.put,  +size, is_lots=True)  # buy OTM put
> self.broker.create_order(self.pulse_index, legs.call, +size, is_lots=True)  # buy OTM call
> ```

## Short strangle

Sell an OTM call and an OTM put - short volatility, collects both premiums while the underlying stays
between the strikes.

* **Max profit** - both premiums (if it stays between the strikes). **Max loss** - unbounded above the call, large below the put.
* **Breakeven** - put strike - premium, or call strike + premium.
* **Risk** - naked on both wings; size conservatively.

> [tab] Manual
>
> ```python theme={null}
> expiry = self.resolver.expiry.relative(
>     underlying_id=u, as_of_time=self.last_pulse, period_type=PeriodType.MONTH,
>     instrument_type=CALL, nth=1, period_id=PeriodID.ALL, min_dte=self._min_dte,
> )[0]
> put_strike  = self.resolver.strike.delta.resolve(   # 20Δ - OTM, lower strike
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.20)
> call_strike = self.resolver.strike.delta.resolve(   # 20Δ - OTM, higher strike
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.20)
> put  = Option(u, PUT,  put_strike,  expiry)
> call = Option(u, CALL, call_strike, expiry)
> size = self._size(call)
> self.broker.create_order(self.pulse_index, put,  -size, is_lots=True)
> self.broker.create_order(self.pulse_index, call, -size, is_lots=True)
> ```

> [tab] Helper
>
> ```python theme={null}
> legs = structures.strangle_by_delta(
>     self.resolver, u, self.last_pulse,
>     call_delta=0.20, put_delta=0.20, min_dte=self._min_dte,
> )
> size = self._size(legs.call)
> self.broker.create_order(self.pulse_index, legs.put,  -size, is_lots=True)  # sell OTM put
> self.broker.create_order(self.pulse_index, legs.call, -size, is_lots=True)  # sell OTM call
> ```

> [!NOTE]
>
> **Delta-hedged, rolling short strangle**
>
> The recipe above is the plain entry. For the full build that delta-hedges the position and rolls it
> over time, see the [Delta-Hedged Short Strangle](https://docs.allasso.ch/dev/pulse/notebooks/delta-hedged-strangle.md) notebook.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.