Management: adjustments, rolls, early closes, early assignment and pin risk.

A live position: what can be decided

Between the opening and the expiration of an option position there are four possible decisions, and each day that passes one of them is taken, even if it is doing nothing:

stateDiagram-v2
  [*] --> Open
  Open --> Adjusted: adjustment
  Adjusted --> Open
  Open --> Closed: close
  Open --> Rolled: roll
  Rolled --> Open: new position
  Open --> Expired: expiration
  Open --> Assigned: exercise
  Closed --> [*]
  Expired --> [*]
  Assigned --> [*]

The lesson uses two synthetic data sets from the level. The ORX options (lessons 3.5.4 and 3.6.1) are European and cash settled: they serve to measure closing and rolling rules. Those of KRN, a fictitious stock with a quarterly dividend, are American and priced with a binomial tree with discrete dividends (lesson 3.4.2 and the data README): they serve for early exercise and pin risk. The results on the data do not say which rule works in a real market; they show how to measure it and where the traps are.

Closing early: five rules measured on ORX

The base strategy is simple: on the day of each monthly expiration, a −0.16 delta put of the next expiration (with 20 days or more) is sold at the bid and managed with a rule. It is the put leg of the strangle in lesson 3.6.1, without leverage: the result is measured in % of each trade's strike.

import numpy as np
import pandas as pd
from scipy.special import ndtr

ind = pd.read_csv("opciones3_indice.csv", parse_dates=["fecha"])
ind = ind.set_index("fecha")
S, r = ind["cierre"], ind["tipo_1m"] / 100
q = ind["rentabilidad_dividendo"] / 100
cad = pd.read_parquet(
    "opciones3_cadena.parquet",
    columns=["fecha", "vencimiento", "tipo", "strike", "bid", "ask",
             "iv_modelo"])
puts = cad[cad["tipo"] == "P"]
por_dia = dict(tuple(puts.groupby("fecha")))
series = {k: g.set_index("fecha")[["bid", "ask"]]
          for k, g in puts.groupby(["vencimiento", "strike"])}
vencs = sorted(puts["vencimiento"].unique())
print(len(por_dia), "days with a chain ·", len(vencs), "expirations")

3017 days with a chain · 147 expirations

def delta_bsm(tipo, S, K, T, iv, r, q):
    d1 = (np.log(S / K) + (r - q + iv**2 / 2) * T) / (iv * np.sqrt(T))
    w = 1.0 if tipo == "C" else -1.0
    return w * np.exp(-q * T) * ndtr(w * d1)


def put_por_delta(f, v, objetivo):
    """Put of expiration v with |delta| closest to the target."""
    g = por_dia[f]
    g = g[g["vencimiento"] == v]
    T = (v - f).days / 365
    d = delta_bsm("P", S[f], g["strike"].to_numpy(), T,
                  g["iv_modelo"].to_numpy(), r[f], q[f])
    return g.iloc[int(np.argmin(np.abs(np.abs(d) - objetivo)))]


def ciclo(objetivo=0.16):
    """Sells a put at the bid on the day of each monthly expiration
    (or the first day with a chain), of the next expiration with
    20 days or more. Returns one trade per cycle."""
    ops, f = [], S.index[0]
    while True:
        while f not in por_dia:
            f = S.index[S.index.get_loc(f) + 1]
        v = next((x for x in vencs if (x - f).days >= 20), None)
        if v is None or v > S.index[-1]:
            return ops
        fila = put_por_delta(f, v, objetivo)
        k = fila["strike"]
        ops.append({"entrada": f, "venc": v, "strike": k,
                    "credito": fila["bid"], "ST": S[v],
                    "cot": series[(v, k)].loc[f:v].iloc[1:]})
        f = v


ops = ciclo(0.16)
cred = pd.Series([100 * o["credito"] / o["strike"] for o in ops])
print(len(ops), "trades · average credit",
      f"{cred.mean():.2f}% of the strike")
pd.DataFrame(ops[:3]).drop(columns="cot")

143 trades · average credit 0.65% of the strike
     entrada       venc  strike  credito       ST
0 2014-01-02 2014-02-21  1700.0      7.5  1882.25
1 2014-02-21 2014-03-21  1800.0      6.7  1839.01
2 2014-03-21 2014-04-17  1750.0      6.7  1793.62

There are 143 trades between 2014 and 2025, with an average credit of 0.65% of the strike: about 0.65 points per 100 of notional, collected in exchange for covering drops below a strike that sits, at the median, 5.8% below the index (between 4.1 and 9.5% in the central 80% of trades). The rules:

• Hold: settlement at expiration, doing nothing.
• 50%: buy back as soon as the put costs half of the credit (the most cited profit target in premium selling).
• 21 days: buy back when 21 calendar days remain, before gamma grows.
• Stop 2×: buy back if the put becomes worth three times the credit (a loss of two credits).
• 50% or 21 days: whichever comes first.

All of them buy back at the ask of the close of the day the condition is met: it is what can be done with daily data, and it is less favorable than an order during the session.

def gestiona(op, objetivo=None, dias=None, stop=None):
    """P&L per unit (points) and exit date. Buys back at the ask
    at the close of the first day a rule is met; otherwise,
    settlement at expiration."""
    for f, (bid, ask) in op["cot"].iterrows():
        if f >= op["venc"]:
            break
        if objetivo is not None and ask <= objetivo * op["credito"]:
            return op["credito"] - ask, f
        if stop is not None and ask >= stop * op["credito"]:
            return op["credito"] - ask, f
        if dias is not None and (op["venc"] - f).days <= dias:
            return op["credito"] - ask, f
    pago = max(op["strike"] - op["ST"], 0.0)
    return op["credito"] - pago, op["venc"]


REGLAS = {"hold": {}, "50%": {"objetivo": 0.5},
          "21 days": {"dias": 21}, "stop 2x": {"stop": 3.0},
          "50% or 21 days": {"objetivo": 0.5, "dias": 21}}


def resultados(ops):
    pnl, dias = {}, {}
    for nombre, kw in REGLAS.items():
        filas = [gestiona(o, **kw) for o in ops]
        pnl[nombre] = pd.Series(
            [100 * x / o["strike"] for (x, _), o in zip(filas, ops)],
            index=[o["entrada"] for o in ops])
        dias[nombre] = np.mean([(f - o["entrada"]).days
                                for (_, f), o in zip(filas, ops)])
    pnl = pd.DataFrame(pnl)  # % of the strike per trade
    tabla = pd.DataFrame({
        "media": pnl.mean(), "mediana": pnl.median(),
        "ganadoras": (pnl > 0).mean(), "peor": pnl.min(),
        "dias": pd.Series(dias), "total": pnl.sum()})
    return pnl, tabla


pnl, tabla = resultados(ops)
tabla.round(2)

                media  mediana  ganadoras   peor   dias  total
hold             0.29     0.55       0.95 -24.97  30.55  41.18
50%              0.17     0.33       0.98 -24.97  11.41  23.80
21 days          0.23     0.25       0.85  -2.10   9.66  33.06
stop 2x          0.46     0.55       0.93  -3.53  29.78  65.75
50% or 21 days   0.22     0.24       0.87  -2.10   7.91  31.46

The table is the summary usually shown to defend a rule, and each column tells a different story. Closing at 50% raises winning trades from 95 to 98% and cuts the holding time from 30.6 to 11.4 days, but lowers the mean from 0.29 to 0.17% per trade and keeps the worst one, −24.97%. The 21-day and stop rules trim the worst trade to −2.10 and −3.53%, and the stop adds up to 65.75 versus 41.18 for holding. Read this way, the stop would seem the best rule. But the table mixes 140 normal months with three episodes:

peores = pnl["hold"].nsmallest(3).index
print("Worst with “hold”:",
      [f.date().isoformat() for f in peores])
pd.DataFrame({"total": pnl.sum(),
              "without the 3 worst": pnl.drop(peores).sum(),
              "in those 3": pnl.loc[peores].sum()}).round(2)

Worst with “hold”: ['2020-02-21', '2018-01-19', '2018-09-21']
                total  without the 3 worst  in those 3
hold            41.18                78.29      -37.12
50%             23.80                48.29      -24.49
21 days         33.06                33.20       -0.15
stop 2x         65.75                72.99       -7.24
50% or 21 days  31.46                31.60       -0.15

The header figure separates the two parts. The three worst trades of “hold” are those opened in February 2020, January 2018 and September 2018: in them, holding loses a total of 37.1 percentage points of the strike, and any rule that exits earlier loses less. In the other 140, holding is the one that adds up the most (78.3), the stop comes close (73.0) and the time rules stay at 33: closing at 21 days gives up half of each month's theta. With 143 cycles, three decide the comparison between rules. If the next crisis arrives in a gap and not over several sessions, or in the second half of the cycle instead of the first, the ranking may change.

The stop also has a problem of its own: it is checked at the close and filled where the market is, not where it was placed.

salidas = []
for o in ops:
    x, f = gestiona(o, stop=3.0)
    if f < o["venc"]:
        salidas.append({"entrada": o["entrada"].date(),
                        "salida": f.date(),
                        "perdida_en_creditos": -x / o["credito"]})
pd.DataFrame(salidas).round(2)

      entrada      salida  perdida_en_creditos
0  2014-02-21  2014-02-27                 2.12
1  2016-06-17  2016-06-24                 2.59
2  2018-01-19  2018-02-02                 2.03
3  2018-09-21  2018-10-18                 6.82
4  2020-02-21  2020-03-09                 6.88
5  2022-06-17  2022-07-07                 2.39
6  2025-02-21  2025-02-28                 2.24
7  2025-03-21  2025-04-04                 4.21

Of eight stops, five fill at a loss of between 2.03 and 2.59 credits, close to the planned 2. Those of the trades opened in September 2018, February 2020 and March 2025 fill at 6.82, 6.88 and 4.21 credits: in a single session the put went from being worth less than three credits to being worth more than five, or almost eight. The 2020 one triggers on 9 March, the day of the −7.9% in the README: a stop checked at the close arrives after the gap. And an intraday stop, on an option price with bid-ask spreads that widen under stress, triggers more easily on noise.

Rolling and adjusting

Rolling is closing a position and opening a similar one further out in time, at another strike or both. It is usually presented as a way to “give time” to a losing trade. The numbers in the data show what it is: two trades. The 2525 put sold on 2018-01-19 goes in the money on 5 February, the day of the −4.2% gap in the README; it is bought back at the ask and a −0.16 delta put of the next expiration is sold at the bid:

o = next(o for o in ops if o["entrada"] == pd.Timestamp("2018-01-19"))
tocada = next(f for f in o["cot"].index if S[f] < o["strike"])
cierre = o["cot"].at[tocada, "ask"]
nueva = put_por_delta(tocada, next(
    x for x in vencs if (x - tocada).days >= 20 and x > o["venc"]),
    0.16)
v2, k2 = nueva["vencimiento"], nueva["strike"]
pago2 = max(k2 - S[v2], 0.0)
print(f"Sold {o['entrada'].date()}: put {o['strike']:.0f} at "
      f"{o['credito']}; tested on {tocada.date()} with ORX {S[tocada]}")
print(f"Buyback at the ask {cierre}; new put {k2:.0f} "
      f"({v2.date()}) at the bid {nueva['bid']}")
pd.Series({
    "hold": o["credito"] - max(o["strike"] - o["ST"], 0),
    "close when tested": o["credito"] - cierre,
    "roll (close + new)": (o["credito"] - cierre
                           + nueva["bid"] - pago2),
    "  of which, the new one": nueva["bid"] - pago2,
}).round(2)

Sold 2018-01-19: put 2525 at 9.9; tested on 2018-02-05 with ORX 2440.24
Buyback at the ask 106.5; new put 2150 (2018-03-16) at the bid 30.2
hold                      -194.87
close when tested          -96.60
roll (close + new)         -66.40
  of which, the new one     30.20
dtype: float64

Held, the put sold at 9.9 points loses 194.87. Closed when tested, 96.60. The roll adds up to −66.40, but that figure merges two trades: the first lost 96.60, realized at the buyback; the second, a March 2150 put sold at 30.2 with volatility soaring, expired worthless and earned 30.20. That the second one went well has nothing to do with the first: it could have been opened without the first, and it would have earned the same. Merging them into a single P&L makes it look as if the roll recovered part of the loss.

Adjustments are variants of the same thing: adding or removing legs to change the Greeks. With the tool from lesson 3.5.4 they can be computed before making them:

Early assignment: American options with dividends

Options on US stocks are American: the holder can exercise them any day. Whoever is short them can be assigned before expiration. The clearing house (OCC) allocates assignments among its members and each broker among its clients with a fixed method, FIFO or random, which it must disclose in writing (FINRA Rule 2360). To know when it happens, you need to know when it suits the holder.

An American option is worth at least its intrinsic value. If it is worth exactly that, exercising now is optimal: waiting adds nothing. For each option, the KRN chain has the American price (precio_modelo, a 150-step binomial tree with discrete dividends) and that of the same European option (europea_modelo). The difference is the early exercise premium:

krn = pd.read_csv("accion3_diario.csv", parse_dates=["fecha"])
krn = krn.set_index("fecha")["cierre"]
ev = pd.read_csv("accion3_eventos.csv", parse_dates=["fecha"])
divs = ev[ev["evento"] == "dividendo"].set_index("fecha")["dividendo"]
op_a = pd.read_parquet("accion3_opciones.parquet")
op_a["S"] = krn.reindex(op_a["fecha"]).to_numpy()
w = np.where(op_a["tipo"] == "C", 1.0, -1.0)
op_a["intr"] = np.maximum(w * (op_a["S"] - op_a["strike"]), 0)
op_a["valor_temporal"] = op_a["precio_modelo"] - op_a["intr"]
op_a["prima_ejercicio"] = (op_a["precio_modelo"]
                           - op_a["europea_modelo"])
# price = intrinsic (± the rounding of the close and of the tree):
# exercising now or at the next opportunity is the same
op_a["ejercer"] = op_a["valor_temporal"] < 0.02
dentro = op_a[op_a["intr"] > 0]
dentro.groupby("tipo")[["prima_ejercicio", "ejercer"]].agg(
    ["mean", "max"]).round(3)

     prima_ejercicio        ejercer
                mean    max    mean   max
tipo
C              0.188  1.019   0.022  True
P              0.335  2.348   0.229  True

Among in-the-money options, the average early exercise premium is 0.19 USD for calls and 0.34 for puts, with maxima of 1.02 and 2.35 USD. The cell considers exercise optimal when the American price exceeds the intrinsic value by less than 2 cents: the close is rounded to the cent and the tree, with steps of a few hours, leaves a cent or so of value for exercising at the next step. With that criterion, exercising now is optimal in 2.2% of the in-the-money call rows and in 22.9% of the put rows. They are two different mechanisms.

Calls: the dividend

A call does not pay a dividend; the stock does. On the eve of the ex-date, the holder of an in-the-money call compares two things: if they exercise, they receive the stock and collect the dividend $D$; if not, the stock drops by $D$ the next day and they keep the option's time value. By put-call parity, that time value is approximately that of the put with the same strike plus the interest on the strike until expiration. Exercising can only pay if

with $\tau$ the time from the ex-date to expiration. The cell checks it against the tree on every ex-date eve in the data:

sesiones = krn.index
vispera = {sesiones[sesiones.get_loc(d) - 1]: d for d in divs.index}
c = dentro[(dentro["tipo"] == "C")
           & dentro["fecha"].isin(list(vispera))].copy()
c["ex"] = c["fecha"].map(vispera)
c = c[c["vencimiento"] >= c["ex"]]
c["D"] = c["ex"].map(divs)
eu_put = op_a[op_a["tipo"] == "P"].set_index(
    ["fecha", "vencimiento", "strike"])["europea_modelo"]
c["put"] = eu_put.reindex(
    pd.MultiIndex.from_frame(c[["fecha", "vencimiento", "strike"]])
).to_numpy()
tau = (c["vencimiento"] - c["ex"]).dt.days / 365
r_c = ind["tipo_1m"].reindex(c["fecha"]).to_numpy() / 100
# what is lost by exercising: the put's insurance and the interest
# on the strike until expiration
c["umbral"] = c["put"] + c["strike"] * (1 - np.exp(-r_c * tau))
c["regla"] = c["D"] > c["umbral"]
print(len(c), "in-the-money calls on the eves")
print(pd.crosstab(c["ejercer"], c["regla"],
                  rownames=["tree: exercise"], colnames=["rule"]))
c[c["ejercer"]].groupby(c["fecha"].dt.year).size()

494 in-the-money calls on the eves
rule            False  True
tree: exercise
False             324     66
True                0    104
fecha
2022    46
2023    22
2024    14
2025    22
dtype: int64

Of 494 in-the-money calls on the eves, the tree exercises 104 and the rule flags those 104 and 66 more. It is a necessary condition, not a sufficient one: in the remaining 66 the tree still finds time value (the approximation ignores the volatility left until expiration, beyond the put's insurance). Optimal exercises appear every year (46 in 2022, 22 in 2023, 14 in 2024 and 22 in 2025) and always in the series that expires one or two weeks after the ex-date: the less time remains, the less time value is sacrificed. An example, the 95 call expiring on 2022-02-18 with the stock at 106-110 USD:

ej = op_a[(op_a["tipo"] == "C") & (op_a["strike"] == 95)
          & (op_a["vencimiento"] == pd.Timestamp("2022-02-18"))]
ej = ej.set_index("fecha").loc["2022-01-27":"2022-02-17"]
ej = ej.assign(europea_menos_intr=ej["europea_modelo"] - ej["intr"])
ej[["S", "precio_modelo", "intr", "valor_temporal",
    "europea_menos_intr"]].iloc[[0, 5, 8, 9, 10, 12]].round(3)

                 S  precio_modelo   intr  valor_temporal  europea_menos_intr
fecha
2022-01-27  109.79         14.806  14.79           0.016              -0.821
2022-02-03  110.43         15.436  15.43           0.006              -0.850
2022-02-08  106.78         11.779  11.78          -0.001              -0.847
2022-02-09  106.84         11.835  11.84          -0.005              -0.857
2022-02-10  106.62         11.639  11.62           0.019               0.019
2022-02-14  105.60         10.606  10.60           0.006               0.006

The American option is worth its intrinsic value plus 0.016 USD on 27 January and practically nothing in the week before the ex-date (0.006 on 3 February; −0.001 and −0.005 on the two eves, due to the rounding of the close). The European one is worth between 0.82 and 0.86 USD less than its intrinsic value: it cannot be exercised and will lose the 0.88 dividend. From 10 February, with no pending dividends, the two coincide. Whoever is short that call must expect to be assigned on the eve: they will deliver 100 shares per contract and, if they did not own them, they will be short on the ex-date and owe the dividend. The diagram summarizes the check a call seller makes before each ex-date (TV is the call's time value, D the dividend):

flowchart TB
  A{Short ITM call} --> B{Ex-date before}
  B -- no --> C[Low risk]
  B -- yes --> D{TV less than D}
  D -- no --> C
  D -- yes --> E[Expect assignment]
  E --> F[Close or roll]

Puts: the interest on the strike

A deep in-the-money put is almost a forward sale of the stock at price K. Exercising it brings forward the receipt of K, which earns interest; waiting keeps an insurance against the stock rising back above K, which is worth little if the put is deep in the money. With positive rates, beyond a certain distance exercising is optimal:

p = dentro[dentro["tipo"] == "P"].copy()
p["dentro_pct"] = 100 * (p["strike"] / p["S"] - 1)
tramo = pd.cut(p["dentro_pct"], [0, 2, 5, 10, 20, 60])
p.groupby(tramo, observed=True).agg(
    filas=("ejercer", "size"), ejercer=("ejercer", "mean"),
    prima_media=("prima_ejercicio", "mean")).round(3)

            filas  ejercer  prima_media
dentro_pct
(0, 2]       3594    0.001        0.065
(2, 5]       5412    0.034        0.099
(5, 10]      8991    0.122        0.184
(10, 20]     9438    0.337        0.377
(20, 60]     7396    0.476        0.767

Near the money, exercise is almost never optimal (0.1% of rows). More than 10% in the money it is optimal in a third of the rows (33.7%), and more than 20% in almost half (47.6%). The early exercise premium grows with the distance, from 0.07 to 0.77 USD on average. For whoever sells puts on stocks, a sharp drop brings a likely early assignment: the purchase of 100 shares per contract earlier than planned, which has to be financed.

Pin risk at expiration

In physically settled options, on expiration day those that finish in the money are exercised automatically unless there is a contrary instruction (the exercise-by-exception procedure of OCC Rule 805) and the holder has until 5:30 p.m. ET to decide (FINRA Rule 2360). If the stock closes right at the strike, the seller does not know until the next day whether they will be assigned: it depends on what the price does after the close and on what the holders decide. That is pin risk.

filas = []
for v in sorted(op_a["vencimiento"].unique()):
    if v > sesiones[-1]:
        continue
    ultimo = op_a.loc[op_a["vencimiento"] == v, "fecha"].max()
    ks = op_a[(op_a["fecha"] == ultimo) & (op_a["vencimiento"] == v)
              & (op_a["tipo"] == "C")].set_index("strike")
    k = ks.index[np.abs(ks.index - krn[v]).argmin()]
    filas.append({"vencimiento": v.date(), "cierre": krn[v],
                  "strike": k, "distancia": krn[v] - k,
                  "interes_abierto": ks.at[k, "interes_abierto"]})
pin = pd.DataFrame(filas)
cerca = pin["distancia"].abs() <= 0.25
print(f"{cerca.sum()} of {len(pin)} expirations within 0.25 USD "
      f"of a strike (at random: {len(pin) * 0.5 / 2.5:.1f})")
pin[cerca].tail(4)

11 of 48 expirations within 0.25 USD of a strike (at random: 9.6)
   vencimiento  cierre  strike  distancia  interes_abierto
28  2024-05-17  137.35   137.5      -0.15             5368
30  2024-07-19  159.84   160.0      -0.16             4967
37  2025-02-21  192.32   192.5      -0.18             6418
46  2025-11-21  172.67   172.5       0.17             4853

In the data, 11 of the 48 KRN expirations close within 0.25 USD of a strike, versus 9.6 that chance would give with strikes every 2.5: in the data there is no attraction toward the strikes, only arithmetic. In real markets the literature documents that the closes of stocks with listed options cluster near the strikes on expiration days (Ni, Pearson and Poteshman, 2005, in the resources). One of the cases in the data, 2024-07-19:

rv = np.log(krn).diff().std()  # daily standard deviation
S_v, K_v, n = 159.84, 160.0, 10
print(f"KRN daily volatility: {rv:.2%}")
print(f"If there is no assignment: 0 shares. If there is: "
      f"{-100 * n} shares at {K_v}")
print(f"One-day risk of 1000 shares: "
      f"{1000 * S_v * rv:,.0f} USD (1 standard deviation)")

KRN daily volatility: 1.69%
If there is no assignment: 0 shares. If there is: -1000 shares at 160.0
One-day risk of 1000 shares: 2,708 USD (1 standard deviation)

KRN closes at 159.84 with 4,967 open contracts at the 160 strike. With 10 short 160 calls, on Monday the position may be zero shares or −1,000. If there is news after the close and the stock rises, the holders will exercise. One day of 1,000 KRN shares is a risk of about 2,700 USD per standard deviation; an earnings release or weekend news, several times that. Short puts have the same problem in reverse.

The delta explains why it cannot be hedged in advance:

Sg = np.array([155.0, 158.0, 159.0, 159.5, 160.0, 160.5, 161.0,
               162.0, 165.0])
perfil = {f"{d} days": delta_bsm("C", Sg, 160.0, d / 365, 0.25,
                                  0.04, 0.0)
          for d in (10, 2, 0.25)}
pd.DataFrame(perfil, index=Sg).round(3)

       10 days  2 days  0.25 days
155.0    0.236   0.045      0.000
158.0    0.399   0.255      0.028
159.0    0.458   0.375      0.171
159.5    0.489   0.441      0.319
160.0    0.519   0.508      0.503
160.5    0.549   0.575      0.686
161.0    0.578   0.640      0.831
162.0    0.636   0.756      0.972
165.0    0.785   0.954      1.000

At 10 days, the delta of the 160 call goes from 0.24 to 0.79 between 155 and 165. Six hours before expiration it is almost a step: 0.03 at 158, 0.50 at 160 and 0.97 at 162. Hedging the delta of an option pinned to the strike in the last session forces you to buy and sell almost the whole notional with each one-dollar move (lesson 3.6.2). The practical solution is to close the short positions near the strike before the close on expiration day, accepting the bid-ask spread.

Cash-settled indices

Options on indices such as SPX are European and cash settled: there is no early assignment or delivery of shares, and the two previous risks disappear. Another one remains: the settlement price. In standard SPX options, according to the Cboe specifications, trading ends the day before (normally a Thursday) and the settlement value (SET) is computed with the opening prices of the components on expiration day: a position held until the end is exposed to Friday's open without being able to close. In the ORX data it settles at the close of expiration day, for simplicity. Before holding a position until expiration, read in the contract specifications how and when the settlement price is set.

Exercises

1. Another delta. Repeat the rules table and the separation of the three worst trades with −0.30 delta puts. Does the conclusion change?

ops30 = ciclo(0.30)
pnl30, tabla30 = resultados(ops30)
peores30 = pnl30["hold"].nsmallest(3).index
print(tabla30.round(2))
pd.DataFrame({"total": pnl30.sum(),
              "without the 3 worst": pnl30.drop(peores30).sum()}).round(2)

                media  mediana  ganadoras   peor   dias  total
hold             0.48     0.98       0.89 -26.01  30.55  68.41
50%              0.27     0.59       0.93 -26.01  13.58  39.12
21 days          0.35     0.39       0.83  -4.73   9.66  49.47
stop 2x          0.63     0.96       0.86 -10.02  29.65  90.05
50% or 21 days   0.32     0.39       0.83  -4.73   8.32  45.27
                total  without the 3 worst
hold            68.41               113.62
50%             39.12                62.82
21 days         49.47                48.26
stop 2x         90.05               105.94
50% or 21 days  45.27                44.07

2. Rolling without lowering the strike. In the 2018 example, instead of selling the March −0.16 delta put, sell the March 2525 put (same strike, more time). Compute the roll's credit and the result of the new trade.

fila = por_dia[tocada]
fila = fila[(fila["vencimiento"] == v2)
            & (fila["strike"] == o["strike"])].iloc[0]
pago = max(o["strike"] - S[v2], 0.0)
print(f"Buyback {cierre} · sale of the March 2525 at "
      f"{fila['bid']} · roll credit {fila['bid'] - cierre:.1f}")
print(f"ORX on {v2.date()}: {S[v2]} · result of the new one: "
      f"{fila['bid'] - pago:.2f}")

Buyback 106.5 · sale of the March 2525 at 139.1 · roll credit 32.6
ORX on 2018-03-16: 2315.19 · result of the new one: -70.71

3. Pin risk. You are short 10 KRN 160 calls and the stock trades at 159.90 one hour before the close on expiration day. List your options and the risk each one leaves.