Finanzwelt: Two-State Economy

Was passiert?

Die Modellwelt hat genau zwei Zeitpunkte: heute (t = 0) und das Laufzeitende nach T = 1,00 Jahr(en). Morgen tritt genau einer von zwei Zuständen ein: „Up“ mit Wahrscheinlichkeit 40,00 % oder „Down“ mit 60,00 %.

Die Anleihe kostet heute 10,00 € und zahlt in beiden Zuständen sicher 11,00 € – das entspricht einem Periodenzins von 10,00 % (10,00 % p. a.).

Die Aktie kostet heute 10,00 € und ist morgen 20,00 € (Up) oder 5,00 € (Down) wert. Ihre erwartete Rendite beträgt 10,00 % bei einer Volatilität von 73,48 %.

Der europäische Call mit Strike K = 15,00 € zahlt morgen max(S1 − K, 0): 5,00 € im Up- und 0,00 € im Down-Zustand.

Warum passiert es?

Weil der Markt vollständig ist (zwei unabhängige Instrumente für zwei Zustände), lässt sich der Call exakt nachbauen: 0,3333 Aktie(n) plus -0,1515 Anleihe(n) liefern in beiden Zuständen genau die Call-Auszahlung. Dieses Replikationsportfolio kostet heute 1,82 € – das ist der einzig arbitragefreie Call-Preis.

Dahinter stehen die Zustandspreise: 1 € im Up-Zustand kostet heute 0,3636 €, 1 € im Down-Zustand 0,5455 €. Jeder Claim ist die Summe seiner zustandsweisen Auszahlungen mal Zustandspreis.

Welche Konsequenzen entstehen?

Der Call ist am Markt überteuert (Marktpreis 2,00 € vs. Replikationspreis 1,82 €). Ein Arbitrageur kassiert heute 0,18 € risikolos; sein Handeln drückt den Preis zurück zum fairen Wert.

Das Portfolio (1,00 Anleihe(n), 1,00 Aktie(n), 1,00 Call(s)) kostet heute 22,00 € und ist morgen 36,00 € (Up) bzw. 16,00 € (Down) wert – Profit 14,00 € bzw. -6,00 €. Erwartete Rendite: 9,09 %, Volatilität: 44,54 %.

Jede Parameteränderung verschiebt dieses Gleichgewicht: Ein höherer Zins verbilligt zukünftige Zahlungen, ein breiterer Up/Down-Spread erhöht Volatilität und Call-Wert, ein höherer Strike drückt den Call-Preis Richtung null.

Zahlungsströme aller Instrumente

Negative Werte heute = Geld fließt ab (Kauf); positive Werte am Laufzeitende = Auszahlung an den Halter.

Cashflows je Marktteilnehmer

Anleger / Aktienkäufer

Aktienherausgeber / Unternehmen

Anleihekäufer / Kreditgeber

Anleiheemittent / Kreditnehmer

Optionskäufer

Optionsverkäufer / Stillhalter

Market Maker

Arbitrageur

Alle Formeln der aktuellen Simulation

Allgemeine Formel → Einsetzung der aktuellen Werte → Ergebnis.

Zins und Diskontierung

Die risikolose Anleihe definiert den Zins der Modellwelt.

Aktie: Rendite und Risiko

Erwartungswert und Streuung der unsicheren Aktienrendite unter den physischen Wahrscheinlichkeiten (p, 1−p).

Call-Option: Payoff

Der europäische Call zahlt am Laufzeitende die Differenz zwischen Aktienwert und Strike – falls positiv.

Replikation und fairer Call-Preis

Ein Portfolio aus φ_B Anleihen und φ_S Aktien soll in beiden Zuständen exakt die Call-Auszahlung liefern: M · φ = C₁.

Zustandspreise (Arrow-Debreu)

Der Preis von 1 € in genau einem Zustand. Jeder Claim ist eine Linearkombination dieser Basis-Wertpapiere.

Arbitrageprüfung

Weicht der Marktpreis vom Replikationspreis ab, existiert eine risikolose Gewinnstrategie.

Portfolio

Das Portfolio ist eine Linearkombination der drei Instrumente.

Der Code, der gerade rechnet

Live per inspect.getsource aus der Finance Engine extrahiert – exakt der Code hinter den angezeigten Zahlen.

Treiber: aktuelle Parameter

Reproduziert die Simulation Schritt für Schritt mit den gerade eingestellten Werten (Kommentare zeigen die tatsächlichen Ergebnisse).

# Genau diese Aufrufe haben die angezeigten Ergebnisse berechnet.
from app.domain.models import (EuropeanCall, PortfolioSpec,
                               RiskFreeBond, RiskyStock, TwoStateEconomy)
from app.finance.cashflows import risk_free_rate
from app.finance.term import annualized_rate
from app.finance.replication import replicate
from app.finance.arrow_debreu import arrow_debreu_prices
from app.finance.risk import expected_return, variance, volatility
from app.finance.portfolio_analysis import analyze_portfolio

economy = TwoStateEconomy(up_probability=0.4)
bond = RiskFreeBond(price_today=10.0, payoff_up=11.0, payoff_down=11.0)
stock = RiskyStock(price_today=10.0, payoff_up=20.0, payoff_down=5.0)
call = EuropeanCall(strike=15.0, market_price=2.0)
spec = PortfolioSpec(bond_units=1.0, stock_units=1.0, call_units=1.0)
T = 1.0

i = risk_free_rate(bond.price_today, bond.payoff_up)          # -> 0.1
i_pa = annualized_rate(i, T)                                  # -> 0.10000000000000009
call_claim = call.payoff(stock)                               # -> (5.0, 0.0)
mu = expected_return(stock.price_today, stock.payoffs, economy.probabilities)  # -> 0.10000000000000003
sigma = volatility(stock.price_today, stock.payoffs, economy.probabilities)     # -> 0.7348469228349535
rep = replicate(bond, stock, call_claim)                      # -> Preis 1.8181818181818181
ad = arrow_debreu_prices(bond, stock)
arb = check_arbitrage(bond, stock, call_claim, call.market_price)  # -> 'overpriced'
pf = analyze_portfolio(spec, bond, stock, call, call_claim,
                       2.0, economy.probabilities)  # -> V0 = 22.0

Zins und Rendite (app.finance.cashflows)

Sicherer Zins aus der Anleihe, Renditebegriffe.

def risk_free_rate(bond_price: float, bond_payoff: float) -> float:
    """Sicherer Zinssatz i = (B1 - B0) / B0 der risikolosen Anleihe."""
    return rate_of_return(bond_price, bond_payoff)


def rate_of_return(price_today: float, payoff_future: float) -> float:
    """Rate of Return r = (c1 - c0) / c0."""
    if price_today == 0:
        raise ValidationError(
            "Die Rendite ist nicht definiert, wenn der heutige Preis 0 ist "
            "(Division durch null)."
        )
    return (payoff_future - price_today) / price_today

Laufzeit (app.finance.term)

Annualisierung des Periodenzinses.

def annualized_rate(period_rate: float, maturity_years: float) -> float:
    """Annualisierter Zins: i_pa = (1 + i)^(1/T) - 1.

    Für T = 1 gilt i_pa = i. Für T > 1 verteilt sich der Periodenzins
    geometrisch auf die Jahre, für T < 1 wird er hochgerechnet.
    """
    if maturity_years <= 0:
        raise ValidationError("Die Laufzeit T muss positiv sein.")
    if period_rate <= -1.0:
        raise ValidationError(
            "Die Annualisierung ist für einen Periodenzins von -100 % oder "
            "darunter nicht definiert."
        )
    return (1.0 + period_rate) ** (1.0 / maturity_years) - 1.0

Risiko (app.finance.risk)

Erwartete Rendite, Varianz, Volatilität.

def expected_return(price_today: float, payoffs: tuple[float, float],
                    probs: tuple[float, float]) -> float:
    p = validate_probabilities(probs)
    r = state_returns(price_today, payoffs)
    return float(p @ r)


def variance(price_today: float, payoffs: tuple[float, float],
             probs: tuple[float, float]) -> float:
    """Var(r) = E[(r - E[r])^2]."""
    p = validate_probabilities(probs)
    r = state_returns(price_today, payoffs)
    mu = float(p @ r)
    return float(p @ (r - mu) ** 2)


def volatility(price_today: float, payoffs: tuple[float, float],
               probs: tuple[float, float]) -> float:
    return math.sqrt(variance(price_today, payoffs, probs))

Replikation (app.finance.replication)

Löst M · φ = C₁ und liefert den fairen Preis.

def payoff_matrix(bond: RiskFreeBond, stock: RiskyStock) -> np.ndarray:
    """Auszahlungsmatrix M: Zeilen = Zustände (up, down), Spalten = (Anleihe, Aktie)."""
    return np.array([
        [bond.payoff_up, stock.payoff_up],
        [bond.payoff_down, stock.payoff_down],
    ], dtype=float)


def replicate(bond: RiskFreeBond, stock: RiskyStock, claim: Claim) -> ReplicationResult:
    """Löst M @ phi = C1. Wirft SingularMarketError bei singulärer Matrix."""
    m = payoff_matrix(bond, stock)
    c = np.asarray(claim.payoffs, dtype=float)
    try:
        phi = np.linalg.solve(m, c)
    except np.linalg.LinAlgError as exc:
        raise SingularMarketError(
            "Die Auszahlungsmatrix ist singulär: Anleihe und Aktie zahlen in beiden "
            "Zuständen proportional aus. Der Markt ist unvollständig, der Claim "
            "kann nicht eindeutig repliziert werden."
        ) from exc
    bond_units, stock_units = float(phi[0]), float(phi[1])
    price = bond_units * bond.price_today + stock_units * stock.price_today
    rep = m @ phi
    verified = bool(np.allclose(rep, c, atol=VERIFY_TOL))
    return ReplicationResult(
        bond_units=bond_units,
        stock_units=stock_units,
        price=price,
        replicated_up=float(rep[0]),
        replicated_down=float(rep[1]),
        verified=verified,
    )

Zustandspreise (app.finance.arrow_debreu)

Arrow-Debreu-Preise über Replikation.

def arrow_debreu_prices(bond: RiskFreeBond, stock: RiskyStock) -> ArrowDebreuResult:
    rep_up = replicate(bond, stock, Claim(1.0, 0.0, "Arrow-Debreu Up"))
    rep_down = replicate(bond, stock, Claim(0.0, 1.0, "Arrow-Debreu Down"))
    return ArrowDebreuResult(
        state_price_up=rep_up.price,
        state_price_down=rep_down.price,
        replication_up=rep_up,
        replication_down=rep_down,
    )

Arbitrage (app.finance.arbitrage)

Vergleich Marktpreis vs. Replikationspreis inklusive Handelsstrategie.

def check_arbitrage(bond: RiskFreeBond, stock: RiskyStock, claim: Claim,
                    market_price: float, tol: float = PRICE_TOL) -> ArbitrageResult:
    rep = replicate(bond, stock, claim)
    deviation = market_price - rep.price

    if abs(deviation) <= tol:
        return ArbitrageResult(
            replication_price=rep.price, market_price=market_price,
            deviation=deviation, status=MispricingStatus.FAIR,
            strategy=["Der Marktpreis entspricht (innerhalb der Toleranz) dem "
                      "Replikationspreis. Es gibt keine Arbitragemöglichkeit."],
            replication=rep,
        )

    if deviation > 0:
        # Claim überteuert: Claim verkaufen, Replikationsportfolio kaufen.
        status = MispricingStatus.OVERPRICED
        strategy = [
            f"Claim am Markt für {market_price:.6f} verkaufen (Short).",
            f"Replikationsportfolio kaufen: {rep.stock_units:.6f} Aktie(n) und "
            f"{rep.bond_units:.6f} Anleihe(n) für {rep.price:.6f}.",
        ]
        cf_today = market_price - rep.price
        cf_up = rep.replicated_up - claim.payoff_up
        cf_down = rep.replicated_down - claim.payoff_down
    else:
        # Claim unterbewertet: Claim kaufen, Replikationsportfolio verkaufen.
        status = MispricingStatus.UNDERPRICED
        strategy = [
            f"Claim am Markt für {market_price:.6f} kaufen (Long).",
            f"Replikationsportfolio verkaufen (short): {rep.stock_units:.6f} Aktie(n) "
            f"und {rep.bond_units:.6f} Anleihe(n) für {rep.price:.6f}.",
        ]
        cf_today = rep.price - market_price
        cf_up = claim.payoff_up - rep.replicated_up
        cf_down = claim.payoff_down - rep.replicated_down

    risk_free = abs(cf_up) <= tol and abs(cf_down) <= tol
    return ArbitrageResult(
        replication_price=rep.price, market_price=market_price,
        deviation=deviation, status=status, strategy=strategy,
        cashflow_today=cf_today, cashflow_up=cf_up, cashflow_down=cf_down,
        risk_free=risk_free, replication=rep,
    )

Portfolio (app.finance.portfolio_analysis)

Bewertung der Linearkombination.

def analyze_portfolio(spec: PortfolioSpec, bond: RiskFreeBond, stock: RiskyStock,
                      call: EuropeanCall, call_claim: Claim, call_price: float,
                      probs: tuple[float, float]) -> PortfolioAnalysis:
    """Bewertet das Portfolio; der Call geht mit `call_price` (Markt- oder
    Replikationspreis) in den heutigen Wert ein."""
    price_today = (spec.bond_units * bond.price_today
                   + spec.stock_units * stock.price_today
                   + spec.call_units * call_price)
    payoff_up = (spec.bond_units * bond.payoff_up
                 + spec.stock_units * stock.payoff_up
                 + spec.call_units * call_claim.payoff_up)
    payoff_down = (spec.bond_units * bond.payoff_down
                   + spec.stock_units * stock.payoff_down
                   + spec.call_units * call_claim.payoff_down)
    payoffs = (payoff_up, payoff_down)

    exp_ret: float | None
    var: float | None
    vol: float | None
    if price_today > 0:
        exp_ret = expected_return(price_today, payoffs, probs)
        var = variance(price_today, payoffs, probs)
        vol = volatility(price_today, payoffs, probs)
    else:
        # Leeres oder kostenloses Portfolio: Renditen sind nicht definiert.
        exp_ret = var = vol = None

    return PortfolioAnalysis(
        spec=spec,
        price_today=price_today,
        payoff_up=payoff_up,
        payoff_down=payoff_down,
        expected_payoff=expectation(payoffs, probs),
        expected_return=exp_ret,
        variance=var,
        volatility=vol,
    )

Payoff-Profile (app.finance.payoff_profiles)

Kurven für die Diagramme (Payoff/Profit über S1).

def call_profile(call: EuropeanCall, grid: np.ndarray,
                 premium: float | None) -> PayoffProfile:
    """Call: Payoff = max(S1 - K, 0), Profit = Payoff - Prämie (falls gegeben)."""
    payoff = np.maximum(grid - call.strike, 0.0)
    cost = premium if premium is not None else 0.0
    return PayoffProfile("Call", tuple(grid.tolist()), tuple(payoff.tolist()),
                         tuple((payoff - cost).tolist()))


def portfolio_profile(spec: PortfolioSpec, bond: RiskFreeBond, stock: RiskyStock,
                      call: EuropeanCall, call_price: float,
                      grid: np.ndarray) -> PayoffProfile:
    """Portfolio: Linearkombination der Instrumentprofile."""
    payoff = (spec.bond_units * np.full_like(grid, float(bond.payoff_up))
              + spec.stock_units * grid
              + spec.call_units * np.maximum(grid - call.strike, 0.0))
    cost = (spec.bond_units * bond.price_today
            + spec.stock_units * stock.price_today
            + spec.call_units * call_price)
    return PayoffProfile("Portfolio", tuple(grid.tolist()), tuple(payoff.tolist()),
                         tuple((payoff - cost).tolist()))

Dieselbe Welt aus neun Blickwinkeln