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

# Three-leg skew

> A short option financed by - or financing - a vertical of the opposite character.

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`). All three legs share one monthly expiry.

## Jade lizard

Sell a put and a call spread, sized so the credit exceeds the call-spread width - no upside risk.

* **Max profit** - the net credit, if price lands between the put and short call.
* **Max loss** - large below the put strike; behaves like a short put on a sell-off.
* **Upside** - none above the calls once the credit ≥ the call-spread width.

> [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(          # 30Δ put
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.30)
> short_call_strike = self.resolver.strike.delta.resolve(   # 30Δ - sell the near call
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.30)
> long_call_strike = self.resolver.strike.delta.resolve(    # 15Δ - buy the far call
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.15)
> put        = Option(u, PUT,  put_strike,        expiry)
> short_call = Option(u, CALL, short_call_strike, expiry)
> long_call  = Option(u, CALL, long_call_strike,  expiry)
> size = self._size(put)
> self.broker.create_order(self.pulse_index, put,        -size, is_lots=True)  # sell put
> self.broker.create_order(self.pulse_index, short_call, -size, is_lots=True)  # sell near call
> self.broker.create_order(self.pulse_index, long_call,  +size, is_lots=True)  # buy far call
> ```

> [tab] Helper
>
> ```python theme={null}
> legs = structures.jade_lizard_by_delta(
>     self.resolver, u, self.last_pulse,
>     put_delta=0.30, short_call_delta=0.30, long_call_delta=0.15, min_dte=self._min_dte,
> )
> size = self._size(legs.put)
> self.broker.create_order(self.pulse_index, legs.put,        -size, is_lots=True)  # sell put
> self.broker.create_order(self.pulse_index, legs.short_call, -size, is_lots=True)  # sell near call
> self.broker.create_order(self.pulse_index, legs.long_call,  +size, is_lots=True)  # buy far call
> ```

## Short jade lizard

The reverse: buy the put and the call spread (long near, short far) - a long-premium debit play that
pays on a large move either way.

* **Max profit** - large below the put strike, plus the call-spread width above.
* **Max loss** - the net debit, if price stalls between the put and the calls.
* **Bias** - long volatility, defined risk.

> [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(         # 30Δ put
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.30)
> near_call_strike = self.resolver.strike.delta.resolve(   # 30Δ - buy the near call
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.30)
> far_call_strike = self.resolver.strike.delta.resolve(    # 15Δ - sell the far call
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.15)
> put       = Option(u, PUT,  put_strike,       expiry)
> near_call = Option(u, CALL, near_call_strike, expiry)
> far_call  = Option(u, CALL, far_call_strike,  expiry)
> size = self._size(put)
> self.broker.create_order(self.pulse_index, put,       +size, is_lots=True)  # buy put
> self.broker.create_order(self.pulse_index, near_call, +size, is_lots=True)  # buy near call
> self.broker.create_order(self.pulse_index, far_call,  -size, is_lots=True)  # sell far call
> ```

> [tab] Helper
>
> ```python theme={null}
> put = structures.option_by_delta(
>     self.resolver, u, self.last_pulse,
>     instrument_type=PUT, delta=0.30, min_dte=self._min_dte,
> ).option
> call_spread = structures.spread_by_delta(   # long 30Δ near / short 15Δ far
>     self.resolver, u, self.last_pulse,
>     instrument_type=CALL, long_delta=0.30, short_delta=0.15, min_dte=self._min_dte,
> )
> size = self._size(put)
> self.broker.create_order(self.pulse_index, put,                     +size, is_lots=True)  # buy put
> self.broker.create_order(self.pulse_index, call_spread.long_option, +size, is_lots=True)  # buy near call
> self.broker.create_order(self.pulse_index, call_spread.short_option, -size, is_lots=True)  # sell far call
> ```

## Seagull

Sell an OTM put to fund a long call spread - a cheap, often near-zero-cost bullish bet leaning long via
the short put.

* **Max profit** - the call-spread width, above the upper call strike.
* **Max loss** - large below the put strike, like being long the underlying.
* **Bias** - bullish; the call spread caps the upside.

> [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(         # 25Δ - sell the put
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.25)
> long_call_strike = self.resolver.strike.delta.resolve(   # 40Δ - buy the lower call
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.40)
> short_call_strike = self.resolver.strike.delta.resolve(  # 20Δ - sell the upper call
>     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)
> long_call  = Option(u, CALL, long_call_strike,  expiry)
> short_call = Option(u, CALL, short_call_strike, expiry)
> size = self._size(put)
> self.broker.create_order(self.pulse_index, put,        -size, is_lots=True)  # sell put
> self.broker.create_order(self.pulse_index, long_call,  +size, is_lots=True)  # buy lower call
> self.broker.create_order(self.pulse_index, short_call, -size, is_lots=True)  # sell upper call
> ```

> [tab] Helper
>
> ```python theme={null}
> put = structures.option_by_delta(
>     self.resolver, u, self.last_pulse,
>     instrument_type=PUT, delta=0.25, min_dte=self._min_dte,
> ).option
> call_spread = structures.spread_by_delta(   # long 40Δ / short 20Δ
>     self.resolver, u, self.last_pulse,
>     instrument_type=CALL, long_delta=0.40, short_delta=0.20, min_dte=self._min_dte,
> )
> size = self._size(put)
> self.broker.create_order(self.pulse_index, put,                     -size, is_lots=True)  # sell put
> self.broker.create_order(self.pulse_index, call_spread.long_option, +size, is_lots=True)  # buy lower call
> self.broker.create_order(self.pulse_index, call_spread.short_option, -size, is_lots=True)  # sell upper call
> ```

## Short seagull

The reverse: hold an OTM put and sell a call spread against it - a bearish, often low-cost downside bet
financed by the short call vertical.

* **Max profit** - large below the put strike, plus the call-spread credit.
* **Max loss** - the call-spread width minus the credit, above the upper call.
* **Bias** - bearish; the short call spread caps gains and loses on a rally.

> [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(         # 25Δ - buy the put
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=PUT, strike_value=0.25)
> lower_call_strike = self.resolver.strike.delta.resolve(  # 40Δ - sell the lower call
>     underlying_id=u, as_of_time=self.last_pulse, expiration_date=expiry,
>     instrument_type=CALL, strike_value=0.40)
> upper_call_strike = self.resolver.strike.delta.resolve(  # 20Δ - buy the upper call
>     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)
> lower_call = Option(u, CALL, lower_call_strike, expiry)
> upper_call = Option(u, CALL, upper_call_strike, expiry)
> size = self._size(put)
> self.broker.create_order(self.pulse_index, put,        +size, is_lots=True)  # buy put
> self.broker.create_order(self.pulse_index, lower_call, -size, is_lots=True)  # sell lower call
> self.broker.create_order(self.pulse_index, upper_call, +size, is_lots=True)  # buy upper call
> ```

> [tab] Helper
>
> ```python theme={null}
> put = structures.option_by_delta(
>     self.resolver, u, self.last_pulse,
>     instrument_type=PUT, delta=0.25, min_dte=self._min_dte,
> ).option
> call_spread = structures.spread_by_delta(   # long 20Δ upper / short 40Δ lower
>     self.resolver, u, self.last_pulse,
>     instrument_type=CALL, long_delta=0.20, short_delta=0.40, min_dte=self._min_dte,
> )
> size = self._size(put)
> self.broker.create_order(self.pulse_index, put,                      +size, is_lots=True)  # buy put
> self.broker.create_order(self.pulse_index, call_spread.short_option, -size, is_lots=True)  # sell lower call
> self.broker.create_order(self.pulse_index, call_spread.long_option,  +size, is_lots=True)  # buy upper call
> ```


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