# Commit now, or enter in stages? A binomial real-options model (Cox, Ross & Rubinstein 1979;
# Dixit & Pindyck 1994). The present value V of a market's future cash flows moves on a monthly
# binomial tree with annual volatility sigma. Full entry costs I = 100 and V0 = 104 (plain NPV +4).
#   Commit:  pay 100 now and receive V; the firm may also abandon at any month for salvage S = 30.
#   Staged:  pay a pilot of 8 now, keeping for 12 months the right to pay the remaining 95 for V.
# Waiting is not free: the project pays out 1 % of V a month, which the staged firm forgoes until it
# scales. Risk-free rate 0.4 % a month. Illustrative numbers, not estimates for any market.
import math

R, Q = 0.004, 0.01

def american(V0, sigma, months, payoff):
    """Value of the right to receive payoff(V) at any month up to `months` (risk-neutral tree)."""
    u = math.exp(sigma * math.sqrt(1 / 12)); d = 1 / u
    p = (1 + R - Q - d) / (u - d)
    vals = [payoff(V0 * u ** j * d ** (months - j)) for j in range(months + 1)]
    for step in range(months - 1, -1, -1):
        vals = [max(payoff(V0 * u ** j * d ** (step - j)), (p * vals[j + 1] + (1 - p) * vals[j]) / (1 + R))
                for j in range(step + 1)]
    return vals[0]

I, S, PILOT, REST, V0 = 100, 30, 8, 95, 104
print("annual volatility | commit, no exit | commit + exit option | staged entry | best of the three")
for sigma in (0.10, 0.25, 0.40, 0.60, 0.80):
    plain = V0 - I
    commit = plain + american(V0, sigma, 36, lambda V: max(S - V, 0))     # abandonment put
    staged = american(V0, sigma, 12, lambda V: max(V - REST, 0)) - PILOT   # expansion call - pilot
    best = max((("commit", commit), ("staged", staged), ("stay out", 0.0)), key=lambda x: x[1])[0]
    print(f"{sigma:17.2f} | {plain:15.1f} | {commit:20.1f} | {staged:12.1f} | {best}")
# annual volatility | commit, no exit | commit + exit option | staged entry | best of the three
#              0.10 |             4.0 |                  4.0 |          1.0 | commit
#              0.25 |             4.0 |                  4.0 |          3.8 | commit
#              0.40 |             4.0 |                  4.9 |          9.1 | staged
#              0.60 |             4.0 |                  7.6 |         16.2 | staged
#              0.80 |             4.0 |                 11.1 |         23.1 | staged

# When to stop a market test: Bayesian optimal stopping solved by dynamic programming (Bellman).
# A new market is either good (monthly contribution +3) or bad (-2); each month's result is that
# mean plus noise with SD 4, so one month says little. Prior P(good) = 0.4. Entry costs 10.
# Each month the firm either stays (earns the month's result, updates its belief) or exits (value 0;
# spending already made is sunk). After 24 months the test is over: a firm still in the market keeps
# it, worth 40 if good and -15 if bad (the bad case still has wind-down costs). Units: arbitrary.
import math, random

G, B, SD, P0, ENTRY, T = 3.0, -2.0, 4.0, 0.4, 10.0, 24
TERM_G, TERM_B = 40.0, -15.0
GRID = [i / 400 for i in range(401)]
NODES = [(-3 + 6 * k / 60) for k in range(61)]                 # quadrature on a standard normal
W = [math.exp(-z * z / 2) for z in NODES]; SW = sum(W); W = [w / SW for w in W]

def update(p, x):
    lg = math.exp(-(x - G) ** 2 / (2 * SD ** 2)); lb = math.exp(-(x - B) ** 2 / (2 * SD ** 2))
    return p * lg / (p * lg + (1 - p) * lb)

def interp(vals, p):
    i = min(int(p * 400), 399); f = p * 400 - i
    return vals[i] * (1 - f) + vals[i + 1] * f

V = [p * TERM_G + (1 - p) * TERM_B for p in GRID]                 # value at the end of month T
threshold = []
for t in range(T - 1, -1, -1):                                   # Bellman: V_t(p) = max(0, E[x + V_{t+1}(p')])
    new, cut = [], None
    for p in GRID:
        cont = 0.0
        for z, w in zip(NODES, W):
            for mean, pm in ((G, p), (B, 1 - p)):
                x = mean + SD * z
                cont += w * pm * (x + interp(V, update(p, x)))
        new.append(max(0.0, cont))
        if cut is None and cont > 0: cut = p
    V = new; threshold.append((t, cut))
print("exit when P(good) falls below:", ", ".join(f"month {t}: {c:.2f}" for t, c in sorted(threshold)
                                                    if t in (1, 3, 6, 12, 18, 23)))
print(f"value of entering with the optimal stopping rule: {interp(V, P0) - ENTRY:+.1f}")

def simulate(policy, runs=20000, seed=1):
    rng = random.Random(seed); total = 0.0; exits = 0
    cut = dict(threshold)
    for _ in range(runs):
        good = rng.random() < P0; p = P0; value = -ENTRY; out = False
        for t in range(T):
            if policy(t, p, cut): out = True; exits += 1; break
            x = (G if good else B) + rng.gauss(0, SD); value += x; p = update(p, x)
        if not out: value += TERM_G if good else TERM_B
        total += value
    return total / runs, exits / runs

pols = {"commit for 24 months, no exit": lambda t, p, c: False,
        "3-month test: exit at month 3 if P(good) < 0.4": lambda t, p, c: t == 3 and p < 0.4,
        "optimal (Bellman) rule": lambda t, p, c: p < c[t]}
for name, pol in pols.items():
    v, e = simulate(pol)
    print(f"{name:48s} mean value {v:+6.1f}   share of runs that exit {e:.0%}")
print("never enter                                      mean value   +0.0")
# exit when P(good) falls below: month 1: 0.05, month 3: 0.05, month 6: 0.06, month 12: 0.07, month 18: 0.09, month 23: 0.28
# value of entering with the optimal stopping rule: +27.9
# commit for 24 months, no exit                    mean value   -2.7   share of runs that exit 0%
# 3-month test: exit at month 3 if P(good) < 0.4   mean value  +20.9   share of runs that exit 57%
# optimal (Bellman) rule                           mean value  +28.9   share of runs that exit 61%
# never enter                                      mean value   +0.0

# A stop-loss exit as a signal. After a joint pilot, the foreign firm exits at month 3. The local
# partner must decide whether to invest again with this firm. Two types of firm, prior 80 / 20:
#   rule-follower - exits only when the market really is bad (it is bad with probability 0.5);
#   opportunist   - exits when the market is bad, and also in 60 % of good markets, walking away
#                   with what the partner built (a low discount factor: it values today over the
#                   relationship).
# The partner joins the next venture only if P(opportunist) < 0.25. A next venture is worth +20 to
# the firm; with an opportunist the partner expects to lose, which is why it screens.
PRIOR_OPP, BAD, GRAB, CUTOFF, NEXT = 0.20, 0.5, 0.6, 0.25, 20.0

def post_opp(l_rule, l_opp):
    return PRIOR_OPP * l_opp / (PRIOR_OPP * l_opp + (1 - PRIOR_OPP) * l_rule)

cases = []
# 1. No stopping rule written on day 1: the partner cannot verify why the firm left.
cases.append(("no written rule, firm exits", BAD, BAD + (1 - BAD) * GRAB))
# 2. A state-contingent rule was written on day 1 (e.g. 'exit if cost per acquired customer stays
#    above X for two consecutive months on the shared dashboard'), and the trigger was hit.
#    Both types exit when the trigger is hit, so the exit itself carries no news about type.
cases.append(("written rule, trigger hit, firm exits", BAD, BAD))
# 3. A rule was written, but the firm exits although the trigger was NOT hit.
cases.append(("written rule, trigger not hit, firm exits", 1e-9, (1 - BAD) * GRAB))
# 4. A rule was written, the trigger was not hit and the firm stays.
cases.append(("written rule, trigger not hit, firm stays", 1 - BAD, (1 - BAD) * (1 - GRAB)))

print("what the partner sees                     | P(opportunist) | joins next venture | firm's value of it")
for label, l_rule, l_opp in cases:
    q = post_opp(l_rule, l_opp)
    join = q < CUTOFF
    print(f"{label:41s} | {PRIOR_OPP:.2f} -> {q:.2f}   | {'yes' if join else 'no':18s} | {NEXT if join else 0:+.0f}")
# Expected reputation value for a rule-follower firm that must exit with probability BAD:
no_rule = BAD * (NEXT if post_opp(BAD, BAD + (1 - BAD) * GRAB) < CUTOFF else 0) + (1 - BAD) * NEXT
rule = BAD * NEXT + (1 - BAD) * NEXT
print(f"honest firm's expected value of the next venture: without a written rule {no_rule:.0f}, with one {rule:.0f}")
print(f"sensitivity: an unexplained exit moves P(opportunist) from 0.20 to {post_opp(BAD, BAD + (1 - BAD) * GRAB):.2f};"
      " it costs the next venture only for partners whose cutoff lies between those two numbers")
# what the partner sees                     | P(opportunist) | joins next venture | firm's value of it
# no written rule, firm exits               | 0.20 -> 0.29   | no                 | +0
# written rule, trigger hit, firm exits     | 0.20 -> 0.20   | yes                | +20
# written rule, trigger not hit, firm exits | 0.20 -> 1.00   | no                 | +0
# written rule, trigger not hit, firm stays | 0.20 -> 0.09   | yes                | +20
# honest firm's expected value of the next venture: without a written rule 10, with one 20
# sensitivity: an unexplained exit moves P(opportunist) from 0.20 to 0.29; it costs the next venture only for partners whose cutoff lies between those two numbers