> ## 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.

# Ladders

> Three same-type, same-expiry options at three strikes (near, mid, far) - a directional play with an extra short (or long) wing tacked on.

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]
>
> **Equidistant vs broken**
>
> `ladder_by_delta(near_delta=…, mid_delta=…)` resolves `near` and `mid` by delta and places
> `far` **equidistant** beyond the mid (`K2-K1 = K3-K2`). For three independently chosen strikes use
> `structures.broken_ladder_by_delta(…, near_delta, mid_delta, far_delta, …)` instead - same `.near` /
> `.mid` / `.far` legs, no equidistant constraint.

## Call ladder

Buy a near call and sell a mid and a far call - a bullish, often-credit structure for a moderate move up.

* **Max profit** - between the mid and far strikes at expiry.
* **Max loss** - unbounded above the far strike: the second short call is naked.
* **Bias** - bullish with a hard ceiling on where the rally can go before the tail bites.

> [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]
> near_strike = self.resolver.strike.delta.resolve(   # 40Δ - near the money
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.40)
> mid_strike  = self.resolver.strike.delta.resolve(   # 25Δ - further OTM
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.25)
> near = Option(u, CALL, near_strike, expiry)
> mid  = Option(u, CALL, mid_strike,  expiry)
> size = self._size(near)
> self.broker.create_order(self.pulse_index, near, +size, is_lots=True)
> self.broker.create_order(self.pulse_index, mid,  -size, is_lots=True)
> # far leg: place a third call further OTM (broken_ladder_by_delta picks it by delta)
> far_strike = self.resolver.strike.delta.resolve(    # 15Δ - the naked wing
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.15)
> far = Option(u, CALL, far_strike, expiry)
> self.broker.create_order(self.pulse_index, far, -size, is_lots=True)
> ```

> [tab] Helper
>
> ```python theme={null}
> legs = structures.ladder_by_delta(
>     self.resolver, u, self.last_pulse,
>     instrument_type=CALL, near_delta=0.40, mid_delta=0.25, min_dte=self._min_dte,
> )
> size = self._size(legs.near)
> self.broker.create_order(self.pulse_index, legs.near, +size, is_lots=True)  # buy near
> self.broker.create_order(self.pulse_index, legs.mid,  -size, is_lots=True)  # sell mid
> self.broker.create_order(self.pulse_index, legs.far,  -size, is_lots=True)  # sell far (equidistant)
> ```

## Short call ladder

Sell a near call and buy a mid and a far call - a call backspread for a strong rally.

* **Max profit** - unbounded above the far strike: two long calls run with the move.
* **Max loss** - capped, around the mid/far strikes on a merely moderate move up.
* **Bias** - long-vol bullish; the short near leg often funds the structure for a credit.

> [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]
> near_strike = self.resolver.strike.delta.resolve(   # 40Δ - near the money
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.40)
> mid_strike  = self.resolver.strike.delta.resolve(   # 25Δ - further OTM
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.25)
> near = Option(u, CALL, near_strike, expiry)
> mid  = Option(u, CALL, mid_strike,  expiry)
> size = self._size(near)
> self.broker.create_order(self.pulse_index, near, -size, is_lots=True)
> self.broker.create_order(self.pulse_index, mid,  +size, is_lots=True)
> far_strike = self.resolver.strike.delta.resolve(    # 15Δ - the long wing
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.15)
> far = Option(u, CALL, far_strike, expiry)
> self.broker.create_order(self.pulse_index, far, +size, is_lots=True)
> ```

> [tab] Helper
>
> ```python theme={null}
> legs = structures.ladder_by_delta(
>     self.resolver, u, self.last_pulse,
>     instrument_type=CALL, near_delta=0.40, mid_delta=0.25, min_dte=self._min_dte,
> )
> size = self._size(legs.near)
> self.broker.create_order(self.pulse_index, legs.near, -size, is_lots=True)  # sell near
> self.broker.create_order(self.pulse_index, legs.mid,  +size, is_lots=True)  # buy mid
> self.broker.create_order(self.pulse_index, legs.far,  +size, is_lots=True)  # buy far (equidistant)
> ```

## Put ladder

Buy a near put and sell a mid and a far put - the put-side mirror of the call ladder, bullish toward a moderate move down.

* **Max profit** - between the far and mid strikes at expiry.
* **Max loss** - large below the far strike: the second short put is effectively naked.
* **Bias** - bearish for a contained slide; the lower tail is the exposure.

> [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=PUT, nth=1, period_id=PeriodID.ALL, min_dte=self._min_dte,
> )[0]
> near_strike = self.resolver.strike.delta.resolve(   # 40Δ - near the money
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.40)
> mid_strike  = self.resolver.strike.delta.resolve(   # 25Δ - further OTM, lower strike
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.25)
> near = Option(u, PUT, near_strike, expiry)
> mid  = Option(u, PUT, mid_strike,  expiry)
> size = self._size(near)
> self.broker.create_order(self.pulse_index, near, +size, is_lots=True)
> self.broker.create_order(self.pulse_index, mid,  -size, is_lots=True)
> far_strike = self.resolver.strike.delta.resolve(    # 15Δ - the naked wing, lower still
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.15)
> far = Option(u, PUT, far_strike, expiry)
> self.broker.create_order(self.pulse_index, far, -size, is_lots=True)
> ```

> [tab] Helper
>
> ```python theme={null}
> legs = structures.ladder_by_delta(
>     self.resolver, u, self.last_pulse,
>     instrument_type=PUT, near_delta=0.40, mid_delta=0.25, min_dte=self._min_dte,
> )
> size = self._size(legs.near)
> self.broker.create_order(self.pulse_index, legs.near, +size, is_lots=True)  # buy near
> self.broker.create_order(self.pulse_index, legs.mid,  -size, is_lots=True)  # sell mid
> self.broker.create_order(self.pulse_index, legs.far,  -size, is_lots=True)  # sell far (equidistant)
> ```

## Short put ladder

Sell a near put and buy a mid and a far put - a put backspread for a strong sell-off.

* **Max profit** - large below the far strike: two long puts run with the drop.
* **Max loss** - capped, around the far/mid strikes on a merely moderate move down.
* **Bias** - long-vol bearish; the short near leg often funds the structure for a credit.

> [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=PUT, nth=1, period_id=PeriodID.ALL, min_dte=self._min_dte,
> )[0]
> near_strike = self.resolver.strike.delta.resolve(   # 40Δ - near the money
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.40)
> mid_strike  = self.resolver.strike.delta.resolve(   # 25Δ - further OTM, lower strike
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.25)
> near = Option(u, PUT, near_strike, expiry)
> mid  = Option(u, PUT, mid_strike,  expiry)
> size = self._size(near)
> self.broker.create_order(self.pulse_index, near, -size, is_lots=True)
> self.broker.create_order(self.pulse_index, mid,  +size, is_lots=True)
> far_strike = self.resolver.strike.delta.resolve(    # 15Δ - the long wing, lower still
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.15)
> far = Option(u, PUT, far_strike, expiry)
> self.broker.create_order(self.pulse_index, far, +size, is_lots=True)
> ```

> [tab] Helper
>
> ```python theme={null}
> legs = structures.ladder_by_delta(
>     self.resolver, u, self.last_pulse,
>     instrument_type=PUT, near_delta=0.40, mid_delta=0.25, min_dte=self._min_dte,
> )
> size = self._size(legs.near)
> self.broker.create_order(self.pulse_index, legs.near, -size, is_lots=True)  # sell near
> self.broker.create_order(self.pulse_index, legs.mid,  +size, is_lots=True)  # buy mid
> self.broker.create_order(self.pulse_index, legs.far,  +size, is_lots=True)  # buy far (equidistant)
> ```


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